sensemaking 0.17.0 → 0.18.0

package/dist/cjs/features/links.js

@@ -9,11 +9,17 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get LINK_EDGES_SQL () {
+        return LINK_EDGES_SQL;
+    },
     get linkEdges () {
         return linkEdges;
     },
     get links () {
         return links;
+    },
+    get toEdges () {
+        return toEdges;
     }
 });
 var _posix = /*#__PURE__*/ _interop_require_default(require("node:path/posix"));
@@ -23,9 +29,49 @@ function _array_like_to_array(arr, len) {
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
 function _array_without_holes(arr) {
     if (Array.isArray(arr)) return _array_like_to_array(arr);
 }
+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 _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -36,12 +82,179 @@ function _iterable_to_array(iter) {
         return Array.from(iter);
     }
 }
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _non_iterable_spread() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
 function _to_consumable_array(arr) {
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
+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 _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array(o, minLen);
@@ -247,21 +460,19 @@ function buildByBase(files) {
     }
     return byBase;
 }
-// Applies resolveTarget to `rows`, writing only rows whose dst actually changes. The UPDATE
-// keys on (src, target): a link/embed sibling pair shares one resolution, so either row's
-// mismatch rewrites both.
-function resolveRows(db, rows, pathSet, byBase) {
-    var update = db.prepare('UPDATE links SET dst = ? WHERE src = ? AND target = ?');
-    var changed = false;
+// resolveTarget applied to `rows`, returning just the rows whose dst actually changed -- the
+// caller writes those in one runBatch call, keyed on (src, target) so a link/embed sibling
+// pair sharing one resolution rewrites both.
+function resolveRows(rows, pathSet, byBase) {
+    var changed = [];
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
         for(var _iterator = rows[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
             var row = _step.value;
             var dst = resolveTarget(row.src, row.target, pathSet, byBase);
-            if (dst !== row.dst) {
-                update.run(dst, row.src, row.target);
-                changed = true;
-            }
+            if (dst !== row.dst) changed.push(_object_spread_props(_object_spread({}, row), {
+                dst: dst
+            }));
         }
     } catch (err) {
         _didIteratorError = true;
@@ -279,220 +490,521 @@ function resolveRows(db, rows, pathSet, byBase) {
     }
     return changed;
 }
+function writeResolved(db, rows) {
+    return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (rows.length === 0) return [
+                        2
+                    ];
+                    return [
+                        4,
+                        db.runBatch('UPDATE links SET dst = ? WHERE src = ? AND target = ?', rows.map(function(r) {
+                            return [
+                                r.dst,
+                                r.src,
+                                r.target
+                            ];
+                        }))
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
 // A new or deleted file can change any note's resolution, so re-resolve the whole table.
 // Fallback for cold builds and large deltas -- see afterReconcile's threshold.
 function resolveAll(db, files) {
-    var pathSet = new Set(files.map(function(f) {
-        return f.relPath;
-    }));
-    var byBase = buildByBase(files);
-    var rows = db.prepare('SELECT src, target, dst, embed FROM links').all();
-    return resolveRows(db, rows, pathSet, byBase);
+    return _async_to_generator(function() {
+        var pathSet, byBase, stmt, rows, changed;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    pathSet = new Set(files.map(function(f) {
+                        return f.relPath;
+                    }));
+                    byBase = buildByBase(files);
+                    return [
+                        4,
+                        db.prepare('SELECT src, target, dst, embed FROM links')
+                    ];
+                case 1:
+                    stmt = _state.sent();
+                    return [
+                        4,
+                        stmt.all()
+                    ];
+                case 2:
+                    rows = _state.sent();
+                    changed = resolveRows(rows, pathSet, byBase);
+                    return [
+                        4,
+                        writeResolved(db, changed)
+                    ];
+                case 3:
+                    _state.sent();
+                    return [
+                        2,
+                        changed.length > 0
+                    ];
+            }
+        });
+    })();
+}
+// Chunked so a large-but-under-threshold delta never exceeds SQLite's bound-variable limit
+// (SQLITE_MAX_VARIABLE_NUMBER, 32766); harmless headroom on DuckDB, which has no such cap.
+function selectIn(db, column, keys) {
+    return _async_to_generator(function() {
+        var rows, i, _stmt, _rows, chunk, stmt, _, _1, _tmp;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    rows = [];
+                    i = 0;
+                    _state.label = 1;
+                case 1:
+                    if (!(i < keys.length)) return [
+                        3,
+                        5
+                    ];
+                    chunk = keys.slice(i, i + 500);
+                    return [
+                        4,
+                        db.prepare("SELECT src, target, dst, embed FROM links WHERE ".concat(column, " IN (").concat(chunk.map(function() {
+                            return '?';
+                        }).join(', '), ")"))
+                    ];
+                case 2:
+                    stmt = _state.sent();
+                    _1 = (_ = (_rows = rows).push).apply;
+                    _tmp = [
+                        _rows
+                    ];
+                    return [
+                        4,
+                        (_stmt = stmt).all.apply(_stmt, _to_consumable_array(chunk))
+                    ];
+                case 3:
+                    _1.apply(_, _tmp.concat([
+                        _to_consumable_array.apply(void 0, [
+                            _state.sent()
+                        ])
+                    ]));
+                    _state.label = 4;
+                case 4:
+                    i += 500;
+                    return [
+                        3,
+                        1
+                    ];
+                case 5:
+                    return [
+                        2,
+                        rows
+                    ];
+            }
+        });
+    })();
 }
 // Re-resolve only what this reconcile could have touched: re-stored sources, links whose
 // target basename matches an added/vanished file, and links whose dst just vanished. All
 // three are indexed lookups, so this never reads the whole table.
 function resolveIncremental(db, delta) {
-    var pathSet = new Set(delta.files.map(function(f) {
-        return f.relPath;
-    }));
-    var byBase = buildByBase(delta.files);
-    var changedBasenames = new Set();
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        for(var _iterator = delta.added[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var p = _step.value;
-            changedBasenames.add(baseKey(p));
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-            }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
-    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-    try {
-        for(var _iterator1 = delta.vanished[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-            var p1 = _step1.value;
-            changedBasenames.add(baseKey(p1));
-        }
-    } catch (err) {
-        _didIteratorError1 = true;
-        _iteratorError1 = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                _iterator1.return();
-            }
-        } finally{
-            if (_didIteratorError1) {
-                throw _iteratorError1;
-            }
-        }
-    }
-    // \0 can't appear in a path or target, so the key never collides; a space can.
-    var candidates = new Map();
-    var collect = function collect(rows) {
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = rows[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var row = _step.value;
-                candidates.set("".concat(row.src, "\0").concat(row.target, "\0").concat(row.embed), row);
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
+    return _async_to_generator(function() {
+        var pathSet, byBase, changedBasenames, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, p, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, p1, candidates, collect, changed;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    pathSet = new Set(delta.files.map(function(f) {
+                        return f.relPath;
+                    }));
+                    byBase = buildByBase(delta.files);
+                    changedBasenames = new Set();
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(_iterator = delta.added[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            p = _step.value;
+                            changedBasenames.add(baseKey(p));
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        for(_iterator1 = delta.vanished[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            p1 = _step1.value;
+                            changedBasenames.add(baseKey(p1));
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                    // \0 can't appear in a path or target, so the key never collides; a space can.
+                    candidates = new Map();
+                    collect = function collect(rows) {
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = rows[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var row = _step.value;
+                                candidates.set("".concat(row.src, "\0").concat(row.target, "\0").concat(row.embed), row);
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                    };
+                    return [
+                        4,
+                        selectIn(db, 'src', delta.reparsed)
+                    ];
+                case 1:
+                    collect.apply(void 0, [
+                        _state.sent()
+                    ]);
+                    return [
+                        4,
+                        selectIn(db, 'target_base', _to_consumable_array(changedBasenames))
+                    ];
+                case 2:
+                    collect.apply(void 0, [
+                        _state.sent()
+                    ]);
+                    return [
+                        4,
+                        selectIn(db, 'dst', delta.vanished)
+                    ];
+                case 3:
+                    collect.apply(void 0, [
+                        _state.sent()
+                    ]);
+                    changed = resolveRows(_to_consumable_array(candidates.values()), pathSet, byBase);
+                    return [
+                        4,
+                        writeResolved(db, changed)
+                    ];
+                case 4:
+                    _state.sent();
+                    return [
+                        2,
+                        changed.length > 0
+                    ];
             }
-        }
-    };
-    // Chunked so a large-but-under-threshold delta never exceeds SQLite's bound-variable
-    // limit (SQLITE_MAX_VARIABLE_NUMBER, 32766).
-    var collectIn = function collectIn(column, keys) {
-        for(var i = 0; i < keys.length; i += 500){
-            var _db_prepare;
-            var chunk = keys.slice(i, i + 500);
-            var placeholders = chunk.map(function() {
-                return '?';
-            }).join(', ');
-            collect((_db_prepare = db.prepare("SELECT src, target, dst, embed FROM links WHERE ".concat(column, " IN (").concat(placeholders, ")"))).all.apply(_db_prepare, _to_consumable_array(chunk)));
-        }
-    };
-    collectIn('src', delta.reparsed);
-    collectIn('target_base', _to_consumable_array(changedBasenames));
-    collectIn('dst', delta.vanished);
-    return resolveRows(db, _to_consumable_array(candidates.values()), pathSet, byBase);
+        });
+    })();
 }
-function linkEdges(db) {
-    // One edge per row, as 0.12's grain always had it -- two written targets resolving to one
-    // dst stay two edges (a weight the fusion evals were gated on). The only exclusion is an
-    // embed whose exact (src, target) also exists as a link: that second row is new with the
-    // embed grain and would double an edge that used to be one row. The NOT EXISTS probes the
-    // primary key and fires only for embed rows; both branches still scan the table.
-    // Self-edges (same-note anchors) are excluded here so PageRank mass is not self-recycled --
-    // Obsidian's own graph view hides self-loops too. The rows themselves stay in the table for
-    // backlinks/peek.
-    var sql = "SELECT src, dst FROM links WHERE dst IS NOT NULL AND embed = 0 AND src != dst\n    UNION ALL\n    SELECT src, dst FROM links l WHERE dst IS NOT NULL AND embed = 1 AND src != dst\n      AND NOT EXISTS (SELECT 1 FROM links l0 WHERE l0.src = l.src AND l0.target = l.target AND l0.embed = 0)";
-    return db.prepare(sql).all().map(function(r) {
+var LINK_EDGES_SQL = "SELECT src, dst FROM links WHERE dst IS NOT NULL AND embed = 0 AND src != dst\n    UNION ALL\n    SELECT src, dst FROM links l WHERE dst IS NOT NULL AND embed = 1 AND src != dst\n      AND NOT EXISTS (SELECT 1 FROM links l0 WHERE l0.src = l.src AND l0.target = l.target AND l0.embed = 0)";
+function toEdges(rows) {
+    return rows.map(function(r) {
         return [
             r.src,
             r.dst
         ];
     });
 }
-// remove() has already deleted the rows by the time afterReconcile runs, so it records here
-// whether they carried edges. Keyed on the delta object, so the state dies with the reconcile.
-var removedWithLinks = new WeakMap();
-function recordRemoved(delta, path) {
-    var set = removedWithLinks.get(delta);
-    if (!set) {
-        set = new Set();
-        removedWithLinks.set(delta, set);
-    }
-    set.add(path);
-}
-// remove() runs per path; the vanished list is an array, so cache the Set per delta.
-var vanishedSets = new WeakMap();
-function vanishedSet(delta) {
-    var set = vanishedSets.get(delta);
-    if (!set) {
-        set = new Set(delta.vanished);
-        vanishedSets.set(delta, set);
-    }
-    return set;
+function linkEdges(db) {
+    return _async_to_generator(function() {
+        var stmt;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        db.prepare(LINK_EDGES_SQL)
+                    ];
+                case 1:
+                    stmt = _state.sent();
+                    return [
+                        4,
+                        stmt.all()
+                    ];
+                case 2:
+                    return [
+                        2,
+                        toEdges.apply(void 0, [
+                            _state.sent()
+                        ])
+                    ];
+            }
+        });
+    })();
 }
+// remove()/store() have already deleted rows by the time afterReconcile runs, so this records
+// whether any reconcile pass deleted at least one link row -- whether a file vanished, or a
+// reparse's stale rows shrank. dstChanged alone misses the reparsed-to-zero-links case (no
+// surviving rows to re-resolve). Keyed on the delta object, so the state dies with the reconcile.
+var removedWithLinks = new WeakMap();
 var links = {
     name: 'links',
     schema: function schema(db) {
-        db.exec('CREATE TABLE IF NOT EXISTS links (src TEXT, target TEXT, target_base TEXT, dst TEXT, embed INTEGER, PRIMARY KEY (src, target, embed))');
-        db.exec('CREATE INDEX IF NOT EXISTS links_dst ON links(dst)');
-        db.exec('CREATE INDEX IF NOT EXISTS links_target_base ON links(target_base)');
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            db.exec('CREATE TABLE IF NOT EXISTS links (src TEXT, target TEXT, target_base TEXT, dst TEXT, embed INTEGER, PRIMARY KEY (src, target, embed))')
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            db.exec('CREATE INDEX IF NOT EXISTS links_dst ON links(dst)')
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            4,
+                            db.exec('CREATE INDEX IF NOT EXISTS links_target_base ON links(target_base)')
+                        ];
+                    case 3:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
     },
     extract: extract,
-    // Reparsed docs are diffed in store() below instead of wiped here: deleting and
-    // re-inserting resets dst to NULL, which made every touch-only reparse read as an edge
-    // change and recompute PageRank -- measured as most of the remaining update cost.
-    remove: function remove(db, path, delta) {
-        if (!vanishedSet(delta).has(path)) return;
-        var result = db.prepare('DELETE FROM links WHERE src = ?').run(path);
-        if (Number(result.changes) > 0) recordRemoved(delta, path);
-    },
-    store: function store(db, path, extracted, delta) {
-        var targets = extracted;
-        // Stale rows (target/embed pairs the new parse no longer contains) are real edge removals.
-        // \0 can't appear in a target, so the composite key never collides.
-        var stale;
-        if (targets.length === 0) {
-            stale = db.prepare('DELETE FROM links WHERE src = ?').run(path);
-        } else {
-            var _db_prepare;
-            var placeholders = targets.map(function() {
-                return '?';
-            }).join(', ');
-            var keys = targets.map(function(t) {
-                return "".concat(t.target, "\0").concat(t.embed ? '1' : '0');
-            });
-            stale = (_db_prepare = db.prepare("DELETE FROM links WHERE src = ? AND (target || char(0) || embed) NOT IN (".concat(placeholders, ")"))).run.apply(_db_prepare, [
-                path
-            ].concat(_to_consumable_array(keys)));
-        }
-        if (Number(stale.changes) > 0) recordRemoved(delta, path);
-        // Upsert preserves dst on surviving rows, so an unchanged link resolves to the same
-        // value and reports no change; only genuinely new rows start at NULL.
-        var insert = db.prepare('INSERT INTO links (src, target, target_base, dst, embed) VALUES (?, ?, ?, NULL, ?) ON CONFLICT(src, target, embed) DO UPDATE SET target_base = excluded.target_base');
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            // A same-note anchor's dst is always its own src, never another file's basename, so it
-            // gets no target_base -- SQL's `IN` never matches NULL, keeping it out of
-            // resolveIncremental's cross-file collectIn('target_base', ...) entirely.
-            for(var _iterator = targets[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var _step_value = _step.value, target = _step_value.target, embed = _step_value.embed;
-                insert.run(path, target, target.startsWith('#') ? null : baseKey(cleanTarget(target)), embed ? 1 : 0);
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
+    remove: // Reparsed docs are diffed in store() below instead of wiped here: deleting and re-inserting
+    // resets dst to NULL, which made every touch-only reparse read as an edge change and
+    // recompute PageRank -- measured as most of the remaining update cost. Only genuinely
+    // vanished files clear here.
+    function remove(db, paths, delta) {
+        return _async_to_generator(function() {
+            var vanishedSet, vanished, existingRows;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        vanishedSet = new Set(delta.vanished);
+                        vanished = paths.filter(function(p) {
+                            return vanishedSet.has(p);
+                        });
+                        if (vanished.length === 0) return [
+                            2
+                        ];
+                        return [
+                            4,
+                            selectIn(db, 'src', vanished)
+                        ];
+                    case 1:
+                        existingRows = _state.sent();
+                        return [
+                            4,
+                            db.runBatch('DELETE FROM links WHERE src = ?', vanished.map(function(p) {
+                                return [
+                                    p
+                                ];
+                            }))
+                        ];
+                    case 2:
+                        _state.sent();
+                        if (existingRows.length > 0) removedWithLinks.set(delta, true);
+                        return [
+                            2
+                        ];
                 }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
+            });
+        })();
+    },
+    store: function store(db, docs, delta) {
+        return _async_to_generator(function() {
+            var byPath, addedSet, reparsedExisting, existingRows, staleRows, upsertRows, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, path, targets, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _step_value1, target, embed;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        byPath = new Map(docs.map(function(d) {
+                            return [
+                                d.path,
+                                d.extracted
+                            ];
+                        }));
+                        addedSet = new Set(delta.added);
+                        reparsedExisting = docs.map(function(d) {
+                            return d.path;
+                        }).filter(function(p) {
+                            return !addedSet.has(p);
+                        });
+                        return [
+                            4,
+                            selectIn(db, 'src', reparsedExisting)
+                        ];
+                    case 1:
+                        existingRows = _state.sent();
+                        staleRows = existingRows.filter(function(row) {
+                            var _byPath_get;
+                            var targets = (_byPath_get = byPath.get(row.src)) !== null && _byPath_get !== void 0 ? _byPath_get : [];
+                            return !targets.some(function(t) {
+                                return t.target === row.target && (t.embed ? 1 : 0) === row.embed;
+                            });
+                        });
+                        if (!(staleRows.length > 0)) return [
+                            3,
+                            3
+                        ];
+                        return [
+                            4,
+                            db.runBatch('DELETE FROM links WHERE src = ? AND target = ? AND embed = ?', staleRows.map(function(r) {
+                                return [
+                                    r.src,
+                                    r.target,
+                                    r.embed
+                                ];
+                            }))
+                        ];
+                    case 2:
+                        _state.sent();
+                        removedWithLinks.set(delta, true);
+                        _state.label = 3;
+                    case 3:
+                        // Upsert preserves dst on surviving rows, so an unchanged link resolves to the same value
+                        // and reports no change; only genuinely new rows start at NULL. A same-note anchor's dst is
+                        // always its own src, never another file's basename, so it gets no target_base -- SQL's
+                        // `IN` never matches NULL, keeping it out of resolveIncremental's target_base lookup.
+                        upsertRows = [];
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(_iterator = byPath[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                _step_value = _sliced_to_array(_step.value, 2), path = _step_value[0], targets = _step_value[1];
+                                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                try {
+                                    for(_iterator1 = targets[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                        _step_value1 = _step1.value, target = _step_value1.target, embed = _step_value1.embed;
+                                        upsertRows.push([
+                                            path,
+                                            target,
+                                            target.startsWith('#') ? null : baseKey(cleanTarget(target)),
+                                            embed ? 1 : 0
+                                        ]);
+                                    }
+                                } catch (err) {
+                                    _didIteratorError1 = true;
+                                    _iteratorError1 = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                            _iterator1.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError1) {
+                                            throw _iteratorError1;
+                                        }
+                                    }
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        if (!(upsertRows.length > 0)) return [
+                            3,
+                            5
+                        ];
+                        return [
+                            4,
+                            db.runBatch('INSERT INTO links (src, target, target_base, dst, embed) VALUES (?, ?, ?, NULL, ?) ON CONFLICT(src, target, embed) DO UPDATE SET target_base = excluded.target_base', upsertRows)
+                        ];
+                    case 4:
+                        _state.sent();
+                        _state.label = 5;
+                    case 5:
+                        return [
+                            2
+                        ];
                 }
-            }
-        }
+            });
+        })();
     },
     afterReconcile: function afterReconcile(db, delta) {
-        var _ref;
-        var _removedWithLinks_get;
-        // Any deleted rows that carried edges mean the edge set shrank -- whether the file
-        // vanished or was reparsed down to fewer/no links. dstChanged alone misses the
-        // reparsed-to-zero-links case (no surviving rows to re-resolve).
-        var removeHadLinks = ((_ref = (_removedWithLinks_get = removedWithLinks.get(delta)) === null || _removedWithLinks_get === void 0 ? void 0 : _removedWithLinks_get.size) !== null && _ref !== void 0 ? _ref : 0) > 0;
-        var churn = delta.reparsed.length + delta.vanished.length;
-        // Past this share of the tree, a full pass is the only one guaranteed to match
-        // resolveTarget's ambiguity rules. A cold build clears the threshold on its own.
-        var large = delta.files.length === 0 || churn > 0.2 * delta.files.length;
-        var dstChanged = large ? resolveAll(db, delta.files) : resolveIncremental(db, delta);
-        delta.linksChanged = dstChanged || removeHadLinks;
+        return _async_to_generator(function() {
+            var _removedWithLinks_get, removeHadLinks, churn, large, dstChanged, _tmp;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        // Any deleted rows mean the edge set shrank -- whether the file vanished or was reparsed
+                        // down to fewer/no links.
+                        removeHadLinks = (_removedWithLinks_get = removedWithLinks.get(delta)) !== null && _removedWithLinks_get !== void 0 ? _removedWithLinks_get : false;
+                        churn = delta.reparsed.length + delta.vanished.length;
+                        // Past this share of the tree, a full pass is the only one guaranteed to match
+                        // resolveTarget's ambiguity rules. A cold build clears the threshold on its own.
+                        large = delta.files.length === 0 || churn > 0.2 * delta.files.length;
+                        if (!large) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            resolveAll(db, delta.files)
+                        ];
+                    case 1:
+                        _tmp = _state.sent();
+                        return [
+                            3,
+                            4
+                        ];
+                    case 2:
+                        return [
+                            4,
+                            resolveIncremental(db, delta)
+                        ];
+                    case 3:
+                        _tmp = _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        dstChanged = _tmp;
+                        delta.linksChanged = dstChanged || removeHadLinks;
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
     }
 };
 /* 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; }