sensemaking 0.21.0 → 0.22.0

package/dist/cjs/store/reconcile.js

@@ -2,9 +2,17 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "reconcile", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get CORE_FRONTMATTER_COLUMNS () {
+        return CORE_FRONTMATTER_COLUMNS;
+    },
+    get reconcile () {
         return reconcile;
     }
 });
@@ -12,7 +20,9 @@ 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 _lockwaitts = require("./lock-wait.js");
 var _sharedts = require("./shared.js");
+var _stagests = require("./stages.js");
 var _transactionts = require("./transaction.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -186,13 +196,6 @@ function _unsupported_iterable_to_array(o, minLen) {
     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);
 }
-// One reconcile algorithm shared by every store, parameterised by a per-engine ReconcileDialect
-// (types.ts). Ordering is universal, not a dialect concern: ALTER, then the frontmatter upsert,
-// then reconcileContent, then preset_files, then the vanished-frontmatter delete, then feature hooks
-// -- a vanished path's content delete (inside reconcileContent) must precede its frontmatter
-// delete, since sqlite's delete SQL resolves the row via its frontmatter rowid.
-// Feature-owned columns (`_rank`) must stay out of the upsert: a reparse would null the last
-// computed value on every touch, not just the reconciles that recompute it.
 var CORE_FRONTMATTER_COLUMNS = new Set([
     'path',
     '_mtime',
@@ -202,23 +205,56 @@ var CORE_FRONTMATTER_COLUMNS = new Set([
 ]);
 function reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths) {
     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, touched, txStart, durationMs;
+        var start, features, stages, elapsed, files, currentSet, existingRows, existing, vanished, toReparse, seenColumns, report, _ref, parsedDocs, warnings, newColumns, workerParseMs, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, col, allColumns, writableColumns, insertSql, added, delta, addedSet, reparsedExisting, touched, txStart, durationMs;
         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;
+                    start = process.hrtime.bigint();
+                    features = (0, _indexts.activeFeatures)(cfg);
+                    stages = (0, _stagests.stageRecorder)(features.map(function(f) {
+                        return f.name;
                     }));
+                    elapsed = function elapsed() {
+                        return Number(process.hrtime.bigint() - start) / 1e6;
+                    };
                     return [
                         4,
-                        conn.prepare('SELECT "path", "_mtime", "_size" FROM frontmatter')
+                        stages.time('list', function() {
+                            return (0, _indexts1.listFiles)(cfg, baseDir);
+                        })
                     ];
                 case 1:
-                    existingStmt = _state.sent();
+                    files = _state.sent();
+                    currentSet = new Set(files.map(function(f) {
+                        return f.relPath;
+                    }));
                     return [
                         4,
-                        existingStmt.all()
+                        stages.time('existing', function() {
+                            return _async_to_generator(function() {
+                                var existingStmt;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                conn.prepare('SELECT "path", "_mtime", "_size" FROM frontmatter')
+                                            ];
+                                        case 1:
+                                            existingStmt = _state.sent();
+                                            return [
+                                                4,
+                                                existingStmt.all()
+                                            ];
+                                        case 2:
+                                            return [
+                                                2,
+                                                _state.sent()
+                                            ];
+                                    }
+                                });
+                            })();
+                        })
                     ];
                 case 2:
                     existingRows = _state.sent();
@@ -247,10 +283,10 @@ function reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths) {
                         2,
                         {
                             parsed: 0,
-                            warnings: []
+                            warnings: [],
+                            stages: stages.take(elapsed(), 0)
                         }
                     ];
-                    features = (0, _indexts.activeFeatures)(cfg);
                     return [
                         4,
                         (0, _sharedts.getColumns)(conn)
@@ -262,12 +298,14 @@ function reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths) {
                     report = (0, _progressts.progress)('reparsing files', toReparse.length);
                     return [
                         4,
-                        (0, _reparsets.reparseFiles)(toReparse, features, cfg, seenColumns, report.tick, {
-                            pool: pool
+                        stages.time('parse', function() {
+                            return (0, _reparsets.reparseFiles)(toReparse, features, cfg, seenColumns, report.tick, {
+                                pool: pool
+                            });
                         })
                     ];
                 case 4:
-                    _ref = _state.sent(), parsedDocs = _ref.docs, warnings = _ref.warnings, newColumns = _ref.newColumns;
+                    _ref = _state.sent(), parsedDocs = _ref.docs, warnings = _ref.warnings, newColumns = _ref.newColumns, workerParseMs = _ref.workerParseMs;
                     report.finish();
                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
@@ -334,7 +372,7 @@ function reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths) {
                         4,
                         (0, _transactionts.withTransaction)(conn, function() {
                             return _async_to_generator(function() {
-                                var _feature_remove, _feature_afterReconcile, present, missingColumns, contentTouched, currentPathsStmt, currentPaths, _, staleAdded, rows, presetRows, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator, _step, doc, _iterator1, _step1, presetName, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, feature, err, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _loop, _iterator3, _step3, err, _iteratorNormalCompletion4, _didIteratorError4, _iteratorError4, _iterator4, _step4, feature1, err;
+                                var present, missingColumns, contentTouched, toRow, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _loop1, _iterator1, _step1, err, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _loop2, _iterator2, _step2, err;
                                 return _ts_generator(this, function(_state) {
                                     switch(_state.label){
                                         case 0:
@@ -353,7 +391,9 @@ function reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths) {
                                             ];
                                             return [
                                                 4,
-                                                dialect.addColumns(conn, missingColumns)
+                                                stages.time('alter', function() {
+                                                    return dialect.addColumns(conn, missingColumns);
+                                                })
                                             ];
                                         case 2:
                                             _state.sent();
@@ -367,37 +407,55 @@ function reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths) {
                                             contentTouched = touched;
                                             if (!(added.length > 0)) return [
                                                 3,
-                                                6
+                                                5
                                             ];
                                             return [
                                                 4,
-                                                conn.prepare('SELECT "path" FROM frontmatter')
+                                                stages.time('added-recheck', function() {
+                                                    return _async_to_generator(function() {
+                                                        var currentPathsStmt, currentPaths, _, staleAdded;
+                                                        return _ts_generator(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    return [
+                                                                        4,
+                                                                        conn.prepare('SELECT "path" FROM frontmatter')
+                                                                    ];
+                                                                case 1:
+                                                                    currentPathsStmt = _state.sent();
+                                                                    _ = Set.bind;
+                                                                    return [
+                                                                        4,
+                                                                        currentPathsStmt.all()
+                                                                    ];
+                                                                case 2:
+                                                                    currentPaths = new (_.apply(Set, [
+                                                                        void 0,
+                                                                        _state.sent().map(function(r) {
+                                                                            return r.path;
+                                                                        })
+                                                                    ]));
+                                                                    staleAdded = added.filter(function(p) {
+                                                                        return currentPaths.has(p);
+                                                                    });
+                                                                    return [
+                                                                        2,
+                                                                        staleAdded.length > 0 ? _to_consumable_array(touched).concat(_to_consumable_array(staleAdded)) : touched
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                })
                                             ];
                                         case 4:
-                                            currentPathsStmt = _state.sent();
-                                            _ = Set.bind;
-                                            return [
-                                                4,
-                                                currentPathsStmt.all()
-                                            ];
+                                            contentTouched = _state.sent();
+                                            _state.label = 5;
                                         case 5:
-                                            currentPaths = new (_.apply(Set, [
-                                                void 0,
-                                                _state.sent().map(function(r) {
-                                                    return r.path;
-                                                })
-                                            ]));
-                                            staleAdded = added.filter(function(p) {
-                                                return currentPaths.has(p);
-                                            });
-                                            if (staleAdded.length > 0) contentTouched = _to_consumable_array(touched).concat(_to_consumable_array(staleAdded));
-                                            _state.label = 6;
-                                        case 6:
                                             if (!(parsedDocs.length > 0)) return [
                                                 3,
-                                                8
+                                                7
                                             ];
-                                            rows = parsedDocs.map(function(doc) {
+                                            toRow = function toRow(doc) {
                                                 return writableColumns.map(function(col) {
                                                     var _doc_data_col;
                                                     if (col === 'path') return doc.relPath;
@@ -408,185 +466,290 @@ function reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths) {
                                                     if (col === '_parse_error') return doc.parseError;
                                                     return (_doc_data_col = doc.data[col]) !== null && _doc_data_col !== void 0 ? _doc_data_col : null;
                                                 });
-                                            });
+                                            };
+                                            // A path in `added` has no existing frontmatter row, so it can never conflict: where a
+                                            // dialect offers a faster append-only path (insertNew), only the rest go through the upsert.
                                             return [
                                                 4,
-                                                conn.runBatch(insertSql, rows)
+                                                stages.time('fm-upsert', function() {
+                                                    return _async_to_generator(function() {
+                                                        var newDocs, updateDocs;
+                                                        return _ts_generator(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    if (!dialect.insertNew) return [
+                                                                        3,
+                                                                        5
+                                                                    ];
+                                                                    newDocs = parsedDocs.filter(function(d) {
+                                                                        return addedSet.has(d.relPath);
+                                                                    });
+                                                                    updateDocs = parsedDocs.filter(function(d) {
+                                                                        return !addedSet.has(d.relPath);
+                                                                    });
+                                                                    if (!(newDocs.length > 0)) return [
+                                                                        3,
+                                                                        2
+                                                                    ];
+                                                                    return [
+                                                                        4,
+                                                                        dialect.insertNew(conn, 'frontmatter', writableColumns, newDocs.map(toRow))
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    _state.label = 2;
+                                                                case 2:
+                                                                    if (!(updateDocs.length > 0)) return [
+                                                                        3,
+                                                                        4
+                                                                    ];
+                                                                    return [
+                                                                        4,
+                                                                        conn.runBatch(insertSql, updateDocs.map(toRow))
+                                                                    ];
+                                                                case 3:
+                                                                    _state.sent();
+                                                                    _state.label = 4;
+                                                                case 4:
+                                                                    return [
+                                                                        3,
+                                                                        7
+                                                                    ];
+                                                                case 5:
+                                                                    return [
+                                                                        4,
+                                                                        conn.runBatch(insertSql, parsedDocs.map(toRow))
+                                                                    ];
+                                                                case 6:
+                                                                    _state.sent();
+                                                                    _state.label = 7;
+                                                                case 7:
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                })
                                             ];
-                                        case 7:
+                                        case 6:
                                             _state.sent();
-                                            _state.label = 8;
-                                        case 8:
+                                            _state.label = 7;
+                                        case 7:
                                             // After the upsert, so every doc already has the frontmatter row sqlite's content rowid
                                             // couples to. ON CONFLICT DO UPDATE preserves that rowid, so a reparse keeps its identity.
                                             return [
                                                 4,
-                                                dialect.reconcileContent(conn, contentTouched, parsedDocs, delta, cfg)
+                                                stages.time('text-index', function() {
+                                                    return dialect.reconcileContent(conn, contentTouched, parsedDocs, delta, cfg);
+                                                })
+                                            ];
+                                        case 8:
+                                            _state.sent();
+                                            // 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.
+                                            return [
+                                                4,
+                                                stages.time('presets', function() {
+                                                    return _async_to_generator(function() {
+                                                        var presetRows, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator, _step, doc, _iterator1, _step1, presetName;
+                                                        return _ts_generator(this, function(_state) {
+                                                            switch(_state.label){
+                                                                case 0:
+                                                                    if (!(touched.length > 0)) return [
+                                                                        3,
+                                                                        2
+                                                                    ];
+                                                                    return [
+                                                                        4,
+                                                                        conn.runBatch('DELETE FROM preset_files WHERE "path" = ?', touched.map(function(p) {
+                                                                            return [
+                                                                                p
+                                                                            ];
+                                                                        }))
+                                                                    ];
+                                                                case 1:
+                                                                    _state.sent();
+                                                                    _state.label = 2;
+                                                                case 2:
+                                                                    presetRows = [];
+                                                                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined, _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                                                    try {
+                                                                        for(_iterator = parsedDocs[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step = _iterator.next()).done); _iteratorNormalCompletion1 = true){
+                                                                            doc = _step.value;
+                                                                            try {
+                                                                                for(_iterator1 = doc.presets[Symbol.iterator](); !(_iteratorNormalCompletion = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion = true){
+                                                                                    presetName = _step1.value;
+                                                                                    presetRows.push([
+                                                                                        doc.relPath,
+                                                                                        presetName
+                                                                                    ]);
+                                                                                }
+                                                                            } catch (err) {
+                                                                                _didIteratorError = true;
+                                                                                _iteratorError = err;
+                                                                            } finally{
+                                                                                try {
+                                                                                    if (!_iteratorNormalCompletion && _iterator1.return != null) {
+                                                                                        _iterator1.return();
+                                                                                    }
+                                                                                } finally{
+                                                                                    if (_didIteratorError) {
+                                                                                        throw _iteratorError;
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    } catch (err) {
+                                                                        _didIteratorError1 = true;
+                                                                        _iteratorError1 = err;
+                                                                    } finally{
+                                                                        try {
+                                                                            if (!_iteratorNormalCompletion1 && _iterator.return != null) {
+                                                                                _iterator.return();
+                                                                            }
+                                                                        } finally{
+                                                                            if (_didIteratorError1) {
+                                                                                throw _iteratorError1;
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    if (!(presetRows.length > 0)) return [
+                                                                        3,
+                                                                        4
+                                                                    ];
+                                                                    return [
+                                                                        4,
+                                                                        conn.runBatch('INSERT INTO preset_files ("path", preset) VALUES (?, ?) ON CONFLICT("path", preset) DO NOTHING', presetRows)
+                                                                    ];
+                                                                case 3:
+                                                                    _state.sent();
+                                                                    _state.label = 4;
+                                                                case 4:
+                                                                    return [
+                                                                        2
+                                                                    ];
+                                                            }
+                                                        });
+                                                    })();
+                                                })
                                             ];
                                         case 9:
                                             _state.sent();
-                                            if (!(touched.length > 0)) return [
+                                            if (!(vanished.length > 0)) return [
                                                 3,
                                                 11
                                             ];
                                             return [
                                                 4,
-                                                conn.runBatch('DELETE FROM preset_files WHERE "path" = ?', touched.map(function(p) {
-                                                    return [
-                                                        p
-                                                    ];
-                                                }))
+                                                stages.time('vanished', function() {
+                                                    return conn.runBatch('DELETE FROM frontmatter WHERE "path" = ?', vanished.map(function(p) {
+                                                        return [
+                                                            p
+                                                        ];
+                                                    }));
+                                                })
                                             ];
                                         case 10:
                                             _state.sent();
                                             _state.label = 11;
                                         case 11:
-                                            presetRows = [];
-                                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined, _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-                                            try {
-                                                for(_iterator = parsedDocs[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step = _iterator.next()).done); _iteratorNormalCompletion1 = true){
-                                                    doc = _step.value;
-                                                    try {
-                                                        for(_iterator1 = doc.presets[Symbol.iterator](); !(_iteratorNormalCompletion = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion = true){
-                                                            presetName = _step1.value;
-                                                            presetRows.push([
-                                                                doc.relPath,
-                                                                presetName
-                                                            ]);
-                                                        }
-                                                    } catch (err) {
-                                                        _didIteratorError = true;
-                                                        _iteratorError = err;
-                                                    } finally{
-                                                        try {
-                                                            if (!_iteratorNormalCompletion && _iterator1.return != null) {
-                                                                _iterator1.return();
-                                                            }
-                                                        } finally{
-                                                            if (_didIteratorError) {
-                                                                throw _iteratorError;
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                            } catch (err) {
-                                                _didIteratorError1 = true;
-                                                _iteratorError1 = err;
-                                            } finally{
-                                                try {
-                                                    if (!_iteratorNormalCompletion1 && _iterator.return != null) {
-                                                        _iterator.return();
-                                                    }
-                                                } finally{
-                                                    if (_didIteratorError1) {
-                                                        throw _iteratorError1;
-                                                    }
-                                                }
-                                            }
-                                            if (!(presetRows.length > 0)) return [
+                                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                            if (!(touched.length > 0)) return [
                                                 3,
-                                                13
-                                            ];
-                                            return [
-                                                4,
-                                                conn.runBatch('INSERT INTO preset_files ("path", preset) VALUES (?, ?) ON CONFLICT("path", preset) DO NOTHING', presetRows)
+                                                19
                                             ];
+                                            _state.label = 12;
                                         case 12:
-                                            _state.sent();
+                                            _state.trys.push([
+                                                12,
+                                                17,
+                                                18,
+                                                19
+                                            ]);
+                                            _loop = function() {
+                                                var feature;
+                                                return _ts_generator(this, function(_state) {
+                                                    switch(_state.label){
+                                                        case 0:
+                                                            feature = _step.value;
+                                                            return [
+                                                                4,
+                                                                stages.time((0, _stagests.featureStage)(feature.name, 'remove'), function() {
+                                                                    var _feature_remove;
+                                                                    return (_feature_remove = feature.remove) === null || _feature_remove === void 0 ? void 0 : _feature_remove.call(feature, conn, touched, delta);
+                                                                })
+                                                            ];
+                                                        case 1:
+                                                            _state.sent();
+                                                            return [
+                                                                2
+                                                            ];
+                                                    }
+                                                });
+                                            };
+                                            _iterator = features[Symbol.iterator]();
                                             _state.label = 13;
                                         case 13:
-                                            if (!(vanished.length > 0)) return [
+                                            if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
                                                 3,
-                                                15
+                                                16
                                             ];
                                             return [
-                                                4,
-                                                conn.runBatch('DELETE FROM frontmatter WHERE "path" = ?', vanished.map(function(p) {
-                                                    return [
-                                                        p
-                                                    ];
-                                                }))
+                                                5,
+                                                _ts_values(_loop())
                                             ];
                                         case 14:
                                             _state.sent();
                                             _state.label = 15;
                                         case 15:
-                                            _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
-                                            if (!(touched.length > 0)) return [
-                                                3,
-                                                23
-                                            ];
-                                            _state.label = 16;
-                                        case 16:
-                                            _state.trys.push([
-                                                16,
-                                                21,
-                                                22,
-                                                23
-                                            ]);
-                                            _iterator2 = features[Symbol.iterator]();
-                                            _state.label = 17;
-                                        case 17:
-                                            if (!!(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done)) return [
-                                                3,
-                                                20
-                                            ];
-                                            feature = _step2.value;
-                                            return [
-                                                4,
-                                                (_feature_remove = feature.remove) === null || _feature_remove === void 0 ? void 0 : _feature_remove.call(feature, conn, touched, delta)
-                                            ];
-                                        case 18:
-                                            _state.sent();
-                                            _state.label = 19;
-                                        case 19:
-                                            _iteratorNormalCompletion2 = true;
+                                            _iteratorNormalCompletion = true;
                                             return [
                                                 3,
-                                                17
+                                                13
                                             ];
-                                        case 20:
+                                        case 16:
                                             return [
                                                 3,
-                                                23
+                                                19
                                             ];
-                                        case 21:
+                                        case 17:
                                             err = _state.sent();
-                                            _didIteratorError2 = true;
-                                            _iteratorError2 = err;
+                                            _didIteratorError = true;
+                                            _iteratorError = err;
                                             return [
                                                 3,
-                                                23
+                                                19
                                             ];
-                                        case 22:
+                                        case 18:
                                             try {
-                                                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-                                                    _iterator2.return();
+                                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                    _iterator.return();
                                                 }
                                             } finally{
-                                                if (_didIteratorError2) {
-                                                    throw _iteratorError2;
+                                                if (_didIteratorError) {
+                                                    throw _iteratorError;
                                                 }
                                             }
                                             return [
                                                 7
                                             ];
-                                        case 23:
-                                            _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
-                                            _state.label = 24;
-                                        case 24:
+                                        case 19:
+                                            _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                            _state.label = 20;
+                                        case 20:
                                             _state.trys.push([
-                                                24,
-                                                29,
-                                                30,
-                                                31
+                                                20,
+                                                25,
+                                                26,
+                                                27
                                             ]);
-                                            _loop = function() {
-                                                var feature, _feature_store, docsForFeature;
+                                            _loop1 = function() {
+                                                var feature, docsForFeature;
                                                 return _ts_generator(this, function(_state) {
                                                     switch(_state.label){
                                                         case 0:
-                                                            feature = _step3.value;
+                                                            feature = _step1.value;
                                                             docsForFeature = parsedDocs.map(function(doc) {
                                                                 return {
                                                                     path: doc.relPath,
@@ -595,7 +758,10 @@ function reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths) {
                                                             });
                                                             return [
                                                                 4,
-                                                                (_feature_store = feature.store) === null || _feature_store === void 0 ? void 0 : _feature_store.call(feature, conn, docsForFeature, delta)
+                                                                stages.time((0, _stagests.featureStage)(feature.name, 'store'), function() {
+                                                                    var _feature_store;
+                                                                    return (_feature_store = feature.store) === null || _feature_store === void 0 ? void 0 : _feature_store.call(feature, conn, docsForFeature, delta);
+                                                                })
                                                             ];
                                                         case 1:
                                                             _state.sent();
@@ -605,110 +771,130 @@ function reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths) {
                                                     }
                                                 });
                                             };
-                                            _iterator3 = features[Symbol.iterator]();
-                                            _state.label = 25;
-                                        case 25:
-                                            if (!!(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done)) return [
+                                            _iterator1 = features[Symbol.iterator]();
+                                            _state.label = 21;
+                                        case 21:
+                                            if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
                                                 3,
-                                                28
+                                                24
                                             ];
                                             return [
                                                 5,
-                                                _ts_values(_loop())
+                                                _ts_values(_loop1())
                                             ];
-                                        case 26:
+                                        case 22:
                                             _state.sent();
-                                            _state.label = 27;
-                                        case 27:
-                                            _iteratorNormalCompletion3 = true;
+                                            _state.label = 23;
+                                        case 23:
+                                            _iteratorNormalCompletion1 = true;
                                             return [
                                                 3,
-                                                25
+                                                21
                                             ];
-                                        case 28:
+                                        case 24:
                                             return [
                                                 3,
-                                                31
+                                                27
                                             ];
-                                        case 29:
+                                        case 25:
                                             err = _state.sent();
-                                            _didIteratorError3 = true;
-                                            _iteratorError3 = err;
+                                            _didIteratorError1 = true;
+                                            _iteratorError1 = err;
                                             return [
                                                 3,
-                                                31
+                                                27
                                             ];
-                                        case 30:
+                                        case 26:
                                             try {
-                                                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-                                                    _iterator3.return();
+                                                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                                    _iterator1.return();
                                                 }
                                             } finally{
-                                                if (_didIteratorError3) {
-                                                    throw _iteratorError3;
+                                                if (_didIteratorError1) {
+                                                    throw _iteratorError1;
                                                 }
                                             }
                                             return [
                                                 7
                                             ];
-                                        case 31:
-                                            _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
-                                            _state.label = 32;
-                                        case 32:
+                                        case 27:
+                                            _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                                            _state.label = 28;
+                                        case 28:
                                             _state.trys.push([
-                                                32,
-                                                37,
-                                                38,
-                                                39
+                                                28,
+                                                33,
+                                                34,
+                                                35
                                             ]);
-                                            _iterator4 = features[Symbol.iterator]();
-                                            _state.label = 33;
-                                        case 33:
-                                            if (!!(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done)) return [
+                                            _loop2 = function() {
+                                                var feature;
+                                                return _ts_generator(this, function(_state) {
+                                                    switch(_state.label){
+                                                        case 0:
+                                                            feature = _step2.value;
+                                                            return [
+                                                                4,
+                                                                stages.time((0, _stagests.featureStage)(feature.name, 'after'), function() {
+                                                                    var _feature_afterReconcile;
+                                                                    return (_feature_afterReconcile = feature.afterReconcile) === null || _feature_afterReconcile === void 0 ? void 0 : _feature_afterReconcile.call(feature, conn, delta);
+                                                                })
+                                                            ];
+                                                        case 1:
+                                                            _state.sent();
+                                                            return [
+                                                                2
+                                                            ];
+                                                    }
+                                                });
+                                            };
+                                            _iterator2 = features[Symbol.iterator]();
+                                            _state.label = 29;
+                                        case 29:
+                                            if (!!(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done)) return [
                                                 3,
-                                                36
+                                                32
                                             ];
-                                            feature1 = _step4.value;
                                             return [
-                                                4,
-                                                (_feature_afterReconcile = feature1.afterReconcile) === null || _feature_afterReconcile === void 0 ? void 0 : _feature_afterReconcile.call(feature1, conn, delta)
+                                                5,
+                                                _ts_values(_loop2())
                                             ];
-                                        case 34:
+                                        case 30:
                                             _state.sent();
-                                            _state.label = 35;
-                                        case 35:
-                                            _iteratorNormalCompletion4 = true;
+                                            _state.label = 31;
+                                        case 31:
+                                            _iteratorNormalCompletion2 = true;
                                             return [
                                                 3,
-                                                33
+                                                29
                                             ];
-                                        case 36:
+                                        case 32:
                                             return [
                                                 3,
-                                                39
+                                                35
                                             ];
-                                        case 37:
+                                        case 33:
                                             err = _state.sent();
-                                            _didIteratorError4 = true;
-                                            _iteratorError4 = err;
+                                            _didIteratorError2 = true;
+                                            _iteratorError2 = err;
                                             return [
                                                 3,
-                                                39
+                                                35
                                             ];
-                                        case 38:
+                                        case 34:
                                             try {
-                                                if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-                                                    _iterator4.return();
+                                                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                                    _iterator2.return();
                                                 }
                                             } finally{
-                                                if (_didIteratorError4) {
-                                                    throw _iteratorError4;
+                                                if (_didIteratorError2) {
+                                                    throw _iteratorError2;
                                                 }
                                             }
                                             return [
                                                 7
                                             ];
-                                        case 39:
+                                        case 35:
                                             return [
                                                 2
                                             ];
@@ -720,13 +906,18 @@ function reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths) {
                 case 5:
                     _state.sent();
                     durationMs = Date.now() - txStart;
+                    // Every store, not just the ones with a PRAGMA to derive: connectUnlocked's lock-wait budget needs it too.
+                    (0, _lockwaitts.recordLockWaitMs)(baseDir, durationMs);
                     if (!dialect.recordDuration) return [
                         3,
                         7
                     ];
                     return [
                         4,
-                        dialect.recordDuration(conn, durationMs)
+                        stages.time('meta', function() {
+                            var _dialect_recordDuration;
+                            return (_dialect_recordDuration = dialect.recordDuration) === null || _dialect_recordDuration === void 0 ? void 0 : _dialect_recordDuration.call(dialect, conn, durationMs);
+                        })
                     ];
                 case 6:
                     _state.sent();
@@ -736,7 +927,8 @@ function reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths) {
                         2,
                         {
                             parsed: parsedDocs.length,
-                            warnings: warnings
+                            warnings: warnings,
+                            stages: stages.take(elapsed(), durationMs, workerParseMs)
                         }
                     ];
             }