sensemaking 0.18.2 → 0.18.4

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

@@ -0,0 +1,793 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "reconcile", {
+    enumerable: true,
+    get: function() {
+        return reconcile;
+    }
+});
+var _errorsts = require("../../errors.js");
+var _indexts = require("../../features/index.js");
+var _progressts = require("../../output/progress.js");
+var _indexts1 = require("../../scan/index.js");
+var _reparsets = require("../../scan/reparse.js");
+var _sharedts = require("../shared.js");
+var _transactionts = require("../transaction.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_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+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 _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+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 _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+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
+        };
+    }
+}
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) {
+        return m.call(o);
+    }
+    if (o && typeof o.length === "number") {
+        return {
+            next: function() {
+                if (o && i >= o.length) {
+                    o = void 0;
+                }
+                return {
+                    value: o && o[i++],
+                    done: !o
+                };
+            }
+        };
+    }
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+// Fork of sqlite/reconcile.ts (house precedent: each store owns its engine-specific SQL), not
+// duckdb's, even though duckdb's content handling is the structurally closer of the two. duckdb
+// dropped sqlite's reconcile_max_ms bookkeeping entirely, and this store's busy timeout (open.ts)
+// is derived from exactly that recorded value -- forking duckdb's file would lose it silently.
+// content itself follows duckdb's shape instead: a plain table, no rowid coupling, no FTS index
+// (phase 2's job, not reconcile's), and no `_seg` sidecars (turso's unspaced-script path is not
+// FTS5-shaped).
+var CORE_FRONTMATTER_COLUMNS = new Set([
+    'path',
+    '_mtime',
+    '_ctime',
+    '_size',
+    '_parse_error'
+]);
+// Not a compile-time cap on ALTER TABLE ADD COLUMN (spike-measured: turso accepts 10,000 with no
+// error). The real fence is a SELECT projecting more than this many result columns, which fails
+// to prepare (spike-measured, both `SELECT *` and an explicit list), so a wide frontmatter table
+// would pass every write silently and only break the first time something selects across it.
+// Enforced here, before ALTER, the same shape as sqlite's compile-time fence.
+var MAX_FRONTMATTER_COLUMNS = 2000;
+// No rowid coupling (unlike sqlite's FTS5 content): `path` is content's own primary key.
+var INSERT_CONTENT_SQL = 'INSERT INTO content ("path", title, summary, text) VALUES (?, ?, ?, ?)';
+function contentRow(doc) {
+    return [
+        doc.relPath,
+        doc.search.title,
+        doc.search.summary,
+        doc.search.text
+    ];
+}
+function reconcile(conn, cfg, baseDir) {
+    return _async_to_generator(function() {
+        var files, currentSet, existingStmt, existingRows, existing, vanished, toReparse, features, seenColumns, report, _ref, parsedDocs, warnings, newColumns, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, col, allColumns, writableColumns, insertSql, added, delta, addedSet, reparsedExisting, txStart, durationMs, prevRaw, prevMax;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    files = (0, _indexts1.listFiles)(cfg, baseDir);
+                    currentSet = new Set(files.map(function(f) {
+                        return f.relPath;
+                    }));
+                    return [
+                        4,
+                        conn.prepare('SELECT "path", "_mtime", "_size" FROM frontmatter')
+                    ];
+                case 1:
+                    existingStmt = _state.sent();
+                    return [
+                        4,
+                        existingStmt.all()
+                    ];
+                case 2:
+                    existingRows = _state.sent();
+                    existing = new Map(existingRows.map(function(r) {
+                        return [
+                            r.path,
+                            r
+                        ];
+                    }));
+                    vanished = existingRows.filter(function(r) {
+                        return !currentSet.has(r.path);
+                    }).map(function(r) {
+                        return r.path;
+                    });
+                    toReparse = files.filter(function(f) {
+                        var row = existing.get(f.relPath);
+                        return !row || row._mtime !== f.mtimeMs || row._size !== f.size;
+                    });
+                    if (vanished.length === 0 && toReparse.length === 0) return [
+                        2,
+                        {
+                            parsed: 0,
+                            warnings: []
+                        }
+                    ];
+                    features = (0, _indexts.activeFeatures)(cfg);
+                    return [
+                        4,
+                        (0, _sharedts.getColumns)(conn)
+                    ];
+                case 3:
+                    seenColumns = _state.sent();
+                    // Bulk reparses (a sync, a cold build) are the long silences a query can hit; short
+                    // reconciles stay silent (progress() has a threshold).
+                    report = (0, _progressts.progress)('reparsing files', toReparse.length);
+                    return [
+                        4,
+                        (0, _reparsets.reparseFiles)(toReparse, features, cfg, seenColumns, report.tick)
+                    ];
+                case 4:
+                    _ref = _state.sent(), parsedDocs = _ref.docs, warnings = _ref.warnings, newColumns = _ref.newColumns;
+                    report.finish();
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(_iterator = newColumns[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            col = _step.value;
+                            seenColumns.add(col);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    allColumns = _to_consumable_array(seenColumns);
+                    if (allColumns.length > MAX_FRONTMATTER_COLUMNS) {
+                        throw new _errorsts.SenseError('COLUMN_LIMIT', "frontmatter would need ".concat(allColumns.length, " columns, crossing turso's SELECT result-set column limit (").concat(MAX_FRONTMATTER_COLUMNS, "; ALTER TABLE ADD COLUMN itself accepts far more, but a query projecting past this many columns fails to prepare). Narrow the presets' include globs so fewer/other files are indexed, or fix whatever is generating unbounded frontmatter keys."));
+                    }
+                    // Columns the frontmatter upsert actually writes: core + parsed frontmatter keys, never a
+                    // feature-owned reserved column (see CORE_FRONTMATTER_COLUMNS above).
+                    writableColumns = allColumns.filter(function(c) {
+                        return CORE_FRONTMATTER_COLUMNS.has(c) || !_indexts1.RESERVED_COLUMNS.has(c);
+                    });
+                    // ON CONFLICT UPDATE (not OR REPLACE) keeps the row's identity stable across reparses.
+                    insertSql = "INSERT INTO frontmatter (".concat(writableColumns.map(_sharedts.quoteIdent).join(', '), ") VALUES (").concat(writableColumns.map(function() {
+                        return '?';
+                    }).join(', '), ') ON CONFLICT("path") DO UPDATE SET ').concat(writableColumns.filter(function(c) {
+                        return c !== 'path';
+                    }).map(function(c) {
+                        return "".concat((0, _sharedts.quoteIdent)(c), " = excluded.").concat((0, _sharedts.quoteIdent)(c));
+                    }).join(', '));
+                    added = toReparse.filter(function(f) {
+                        return !existing.has(f.relPath);
+                    }).map(function(f) {
+                        return f.relPath;
+                    });
+                    delta = {
+                        files: files,
+                        reparsed: parsedDocs.map(function(d) {
+                            return d.relPath;
+                        }),
+                        added: added,
+                        vanished: vanished
+                    };
+                    addedSet = new Set(added);
+                    reparsedExisting = parsedDocs.map(function(d) {
+                        return d.relPath;
+                    }).filter(function(p) {
+                        return !addedSet.has(p);
+                    });
+                    txStart = Date.now();
+                    return [
+                        4,
+                        (0, _transactionts.withTransaction)(conn, function() {
+                            return _async_to_generator(function() {
+                                var _feature_remove, _feature_afterReconcile, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, col, err, rows, contentTouched, presetTouched, presetRows, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator1, _step1, doc, _iterator2, _step2, presetName, removedPaths, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, feature, err, _iteratorNormalCompletion4, _didIteratorError4, _iteratorError4, _loop, _iterator4, _step4, err, _iteratorNormalCompletion5, _didIteratorError5, _iteratorError5, _iterator5, _step5, feature1, err;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                            _state.label = 1;
+                                        case 1:
+                                            _state.trys.push([
+                                                1,
+                                                6,
+                                                7,
+                                                8
+                                            ]);
+                                            _iterator = newColumns[Symbol.iterator]();
+                                            _state.label = 2;
+                                        case 2:
+                                            if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                                3,
+                                                5
+                                            ];
+                                            col = _step.value;
+                                            return [
+                                                4,
+                                                conn.exec("ALTER TABLE frontmatter ADD COLUMN ".concat((0, _sharedts.quoteIdent)(col)))
+                                            ];
+                                        case 3:
+                                            _state.sent();
+                                            _state.label = 4;
+                                        case 4:
+                                            _iteratorNormalCompletion = true;
+                                            return [
+                                                3,
+                                                2
+                                            ];
+                                        case 5:
+                                            return [
+                                                3,
+                                                8
+                                            ];
+                                        case 6:
+                                            err = _state.sent();
+                                            _didIteratorError = true;
+                                            _iteratorError = err;
+                                            return [
+                                                3,
+                                                8
+                                            ];
+                                        case 7:
+                                            try {
+                                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                    _iterator.return();
+                                                }
+                                            } finally{
+                                                if (_didIteratorError) {
+                                                    throw _iteratorError;
+                                                }
+                                            }
+                                            return [
+                                                7
+                                            ];
+                                        case 8:
+                                            if (!(parsedDocs.length > 0)) return [
+                                                3,
+                                                10
+                                            ];
+                                            rows = parsedDocs.map(function(doc) {
+                                                return writableColumns.map(function(col) {
+                                                    var _doc_data_col;
+                                                    if (col === 'path') return doc.relPath;
+                                                    if (col === '_mtime') return doc.mtimeMs;
+                                                    if (col === '_ctime') return doc.ctimeMs;
+                                                    if (col === '_size') return doc.size;
+                                                    // Written per parse, unlike _rank, which a feature pass owns and the upsert skips.
+                                                    if (col === '_parse_error') return doc.parseError;
+                                                    return (_doc_data_col = doc.data[col]) !== null && _doc_data_col !== void 0 ? _doc_data_col : null;
+                                                });
+                                            });
+                                            return [
+                                                4,
+                                                conn.runBatch(insertSql, rows)
+                                            ];
+                                        case 9:
+                                            _state.sent();
+                                            _state.label = 10;
+                                        case 10:
+                                            // content is a plain table keyed by its own path (no rowid subquery, unlike sqlite's FTS5
+                                            // content), so vanished and reparsed docs delete in one pass.
+                                            contentTouched = _to_consumable_array(vanished).concat(_to_consumable_array(reparsedExisting));
+                                            if (!(contentTouched.length > 0)) return [
+                                                3,
+                                                12
+                                            ];
+                                            return [
+                                                4,
+                                                conn.runBatch('DELETE FROM content WHERE "path" = ?', contentTouched.map(function(p) {
+                                                    return [
+                                                        p
+                                                    ];
+                                                }))
+                                            ];
+                                        case 11:
+                                            _state.sent();
+                                            _state.label = 12;
+                                        case 12:
+                                            if (!(parsedDocs.length > 0)) return [
+                                                3,
+                                                14
+                                            ];
+                                            return [
+                                                4,
+                                                conn.runBatch(INSERT_CONTENT_SQL, parsedDocs.map(contentRow))
+                                            ];
+                                        case 13:
+                                            _state.sent();
+                                            _state.label = 14;
+                                        case 14:
+                                            if (!(vanished.length > 0)) return [
+                                                3,
+                                                16
+                                            ];
+                                            return [
+                                                4,
+                                                conn.runBatch('DELETE FROM frontmatter WHERE "path" = ?', vanished.map(function(p) {
+                                                    return [
+                                                        p
+                                                    ];
+                                                }))
+                                            ];
+                                        case 15:
+                                            _state.sent();
+                                            _state.label = 16;
+                                        case 16:
+                                            // A preset edit forces a full rebuild, so an unchanged doc's coverage is already correct;
+                                            // new docs have nothing to clear, which keeps cold builds linear.
+                                            presetTouched = _to_consumable_array(vanished).concat(_to_consumable_array(reparsedExisting));
+                                            if (!(presetTouched.length > 0)) return [
+                                                3,
+                                                18
+                                            ];
+                                            return [
+                                                4,
+                                                conn.runBatch('DELETE FROM preset_files WHERE "path" = ?', presetTouched.map(function(p) {
+                                                    return [
+                                                        p
+                                                    ];
+                                                }))
+                                            ];
+                                        case 17:
+                                            _state.sent();
+                                            _state.label = 18;
+                                        case 18:
+                                            presetRows = [];
+                                            _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined, _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                                            try {
+                                                for(_iterator1 = parsedDocs[Symbol.iterator](); !(_iteratorNormalCompletion2 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion2 = true){
+                                                    doc = _step1.value;
+                                                    try {
+                                                        for(_iterator2 = doc.presets[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion1 = true){
+                                                            presetName = _step2.value;
+                                                            presetRows.push([
+                                                                doc.relPath,
+                                                                presetName
+                                                            ]);
+                                                        }
+                                                    } catch (err) {
+                                                        _didIteratorError1 = true;
+                                                        _iteratorError1 = err;
+                                                    } finally{
+                                                        try {
+                                                            if (!_iteratorNormalCompletion1 && _iterator2.return != null) {
+                                                                _iterator2.return();
+                                                            }
+                                                        } finally{
+                                                            if (_didIteratorError1) {
+                                                                throw _iteratorError1;
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            } catch (err) {
+                                                _didIteratorError2 = true;
+                                                _iteratorError2 = err;
+                                            } finally{
+                                                try {
+                                                    if (!_iteratorNormalCompletion2 && _iterator1.return != null) {
+                                                        _iterator1.return();
+                                                    }
+                                                } finally{
+                                                    if (_didIteratorError2) {
+                                                        throw _iteratorError2;
+                                                    }
+                                                }
+                                            }
+                                            if (!(presetRows.length > 0)) return [
+                                                3,
+                                                20
+                                            ];
+                                            return [
+                                                4,
+                                                conn.runBatch('INSERT INTO preset_files ("path", preset) VALUES (?, ?)', presetRows)
+                                            ];
+                                        case 19:
+                                            _state.sent();
+                                            _state.label = 20;
+                                        case 20:
+                                            removedPaths = _to_consumable_array(vanished).concat(_to_consumable_array(reparsedExisting));
+                                            _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
+                                            if (!(removedPaths.length > 0)) return [
+                                                3,
+                                                28
+                                            ];
+                                            _state.label = 21;
+                                        case 21:
+                                            _state.trys.push([
+                                                21,
+                                                26,
+                                                27,
+                                                28
+                                            ]);
+                                            _iterator3 = features[Symbol.iterator]();
+                                            _state.label = 22;
+                                        case 22:
+                                            if (!!(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done)) return [
+                                                3,
+                                                25
+                                            ];
+                                            feature = _step3.value;
+                                            return [
+                                                4,
+                                                (_feature_remove = feature.remove) === null || _feature_remove === void 0 ? void 0 : _feature_remove.call(feature, conn, removedPaths, delta)
+                                            ];
+                                        case 23:
+                                            _state.sent();
+                                            _state.label = 24;
+                                        case 24:
+                                            _iteratorNormalCompletion3 = true;
+                                            return [
+                                                3,
+                                                22
+                                            ];
+                                        case 25:
+                                            return [
+                                                3,
+                                                28
+                                            ];
+                                        case 26:
+                                            err = _state.sent();
+                                            _didIteratorError3 = true;
+                                            _iteratorError3 = err;
+                                            return [
+                                                3,
+                                                28
+                                            ];
+                                        case 27:
+                                            try {
+                                                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                                                    _iterator3.return();
+                                                }
+                                            } finally{
+                                                if (_didIteratorError3) {
+                                                    throw _iteratorError3;
+                                                }
+                                            }
+                                            return [
+                                                7
+                                            ];
+                                        case 28:
+                                            _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
+                                            _state.label = 29;
+                                        case 29:
+                                            _state.trys.push([
+                                                29,
+                                                34,
+                                                35,
+                                                36
+                                            ]);
+                                            _loop = function() {
+                                                var feature, _feature_store, docsForFeature;
+                                                return _ts_generator(this, function(_state) {
+                                                    switch(_state.label){
+                                                        case 0:
+                                                            feature = _step4.value;
+                                                            docsForFeature = parsedDocs.map(function(doc) {
+                                                                return {
+                                                                    path: doc.relPath,
+                                                                    extracted: doc.extracted[feature.name]
+                                                                };
+                                                            });
+                                                            return [
+                                                                4,
+                                                                (_feature_store = feature.store) === null || _feature_store === void 0 ? void 0 : _feature_store.call(feature, conn, docsForFeature, delta)
+                                                            ];
+                                                        case 1:
+                                                            _state.sent();
+                                                            return [
+                                                                2
+                                                            ];
+                                                    }
+                                                });
+                                            };
+                                            _iterator4 = features[Symbol.iterator]();
+                                            _state.label = 30;
+                                        case 30:
+                                            if (!!(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done)) return [
+                                                3,
+                                                33
+                                            ];
+                                            return [
+                                                5,
+                                                _ts_values(_loop())
+                                            ];
+                                        case 31:
+                                            _state.sent();
+                                            _state.label = 32;
+                                        case 32:
+                                            _iteratorNormalCompletion4 = true;
+                                            return [
+                                                3,
+                                                30
+                                            ];
+                                        case 33:
+                                            return [
+                                                3,
+                                                36
+                                            ];
+                                        case 34:
+                                            err = _state.sent();
+                                            _didIteratorError4 = true;
+                                            _iteratorError4 = err;
+                                            return [
+                                                3,
+                                                36
+                                            ];
+                                        case 35:
+                                            try {
+                                                if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                                                    _iterator4.return();
+                                                }
+                                            } finally{
+                                                if (_didIteratorError4) {
+                                                    throw _iteratorError4;
+                                                }
+                                            }
+                                            return [
+                                                7
+                                            ];
+                                        case 36:
+                                            _iteratorNormalCompletion5 = true, _didIteratorError5 = false, _iteratorError5 = undefined;
+                                            _state.label = 37;
+                                        case 37:
+                                            _state.trys.push([
+                                                37,
+                                                42,
+                                                43,
+                                                44
+                                            ]);
+                                            _iterator5 = features[Symbol.iterator]();
+                                            _state.label = 38;
+                                        case 38:
+                                            if (!!(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done)) return [
+                                                3,
+                                                41
+                                            ];
+                                            feature1 = _step5.value;
+                                            return [
+                                                4,
+                                                (_feature_afterReconcile = feature1.afterReconcile) === null || _feature_afterReconcile === void 0 ? void 0 : _feature_afterReconcile.call(feature1, conn, delta)
+                                            ];
+                                        case 39:
+                                            _state.sent();
+                                            _state.label = 40;
+                                        case 40:
+                                            _iteratorNormalCompletion5 = true;
+                                            return [
+                                                3,
+                                                38
+                                            ];
+                                        case 41:
+                                            return [
+                                                3,
+                                                44
+                                            ];
+                                        case 42:
+                                            err = _state.sent();
+                                            _didIteratorError5 = true;
+                                            _iteratorError5 = err;
+                                            return [
+                                                3,
+                                                44
+                                            ];
+                                        case 43:
+                                            try {
+                                                if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+                                                    _iterator5.return();
+                                                }
+                                            } finally{
+                                                if (_didIteratorError5) {
+                                                    throw _iteratorError5;
+                                                }
+                                            }
+                                            return [
+                                                7
+                                            ];
+                                        case 44:
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        })
+                    ];
+                case 5:
+                    _state.sent();
+                    // Reconcile's own write-transaction duration, for open()'s derived busy_timeout: keep the
+                    // observed max so a big watcher reconcile's lock hold is what the next open bounds its wait
+                    // against (the same mechanism sqlite's reconcile records, and the one this store's busy
+                    // timeout is derived from).
+                    durationMs = Date.now() - txStart;
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'reconcile_max_ms')
+                    ];
+                case 6:
+                    prevRaw = _state.sent();
+                    // -1, not 0, so a genuinely 0ms first reconcile (sub-millisecond, common on a tiny tree)
+                    // still gets recorded instead of losing to the "nothing recorded yet" default.
+                    prevMax = prevRaw === null ? -1 : Number(prevRaw);
+                    if (!(durationMs > prevMax)) return [
+                        3,
+                        8
+                    ];
+                    return [
+                        4,
+                        (0, _sharedts.setMeta)(conn, 'reconcile_max_ms', String(durationMs))
+                    ];
+                case 7:
+                    _state.sent();
+                    _state.label = 8;
+                case 8:
+                    return [
+                        2,
+                        {
+                            parsed: parsedDocs.length,
+                            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; }