sensemaking 0.24.4 → 0.24.6

package/dist/cjs/watch.js

@@ -9,10 +9,11 @@ Object.defineProperty(exports, "runWatch", {
     }
 });
 var _nodefs = require("node:fs");
-var _indexts = require("./config/index.js");
 var _errorsts = require("./errors.js");
 var _guardedtickts = require("./lib/guarded-tick.js");
-var _indexts1 = require("./store/index.js");
+var _watchnotificationts = require("./lib/watch-notification.js");
+var _indexts = require("./store/index.js");
+var _watchclaimts = require("./watch-claim.js");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -39,6 +40,12 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -140,11 +147,9 @@ function _ts_generator(thisArg, body) {
 }
 // Watch is a cache pre-warmer, not a correctness mechanism: open() always reconciles anyway, so any fs event just triggers a debounced full reconcile.
 var DEBOUNCE_MS = 200;
-var HEARTBEAT_INTERVAL_MS = 5000;
-var STALE_HEARTBEAT_MS = 15000;
 function runWatch(_0) {
     return _async_to_generator(function(cfg) {
-        var opts, _opts_onEvent, _opts_debounceMs, _opts_heartbeatIntervalMs, _cfg_rootDir, onEvent, debounceMs, heartbeatIntervalMs, _ref, initialStore, dbPath, initialWarnings, initialParsed, rootDir, existingHeartbeat, age, initialTotal, _tmp, stopping, running, queuedAlways, tick, startCycle, requestCycle, debounceTimer, scheduleReconcile, watcher, heartbeatTimer;
+        var opts, _opts_onEvent, _opts_debounceMs, _opts_heartbeatIntervalMs, _cfg_rootDir, _cfg_configDir, _opts_force, onEvent, debounceMs, reconcileIntervalMs, claimIntervalMs, rootDir, configDir, claimFailure, requestShutdown, claim, claimCloseStarted, closeClaim, _ref, initialStore, dbPath, initialWarnings, initialParsed, initialTotal, _tmp, stopping, running, queuedAlways, tick, startCycle, requestCycle, debounceTimer, scheduleReconcile, watcher, reconcileTimer, err, closeError;
         var _arguments = arguments;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
@@ -152,45 +157,57 @@ function runWatch(_0) {
                     opts = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
                     onEvent = (_opts_onEvent = opts.onEvent) !== null && _opts_onEvent !== void 0 ? _opts_onEvent : function() {};
                     debounceMs = (_opts_debounceMs = opts.debounceMs) !== null && _opts_debounceMs !== void 0 ? _opts_debounceMs : DEBOUNCE_MS;
-                    heartbeatIntervalMs = (_opts_heartbeatIntervalMs = opts.heartbeatIntervalMs) !== null && _opts_heartbeatIntervalMs !== void 0 ? _opts_heartbeatIntervalMs : HEARTBEAT_INTERVAL_MS;
-                    return [
-                        4,
-                        (0, _indexts1.openStore)(cfg)
-                    ];
-                case 1:
-                    _ref = _state.sent(), initialStore = _ref.store, dbPath = _ref.dbPath, initialWarnings = _ref.warnings, initialParsed = _ref.parsed;
-                    // openStore normalizes the legacy direct-API baseDir before a watcher touches the filesystem.
+                    reconcileIntervalMs = (_opts_heartbeatIntervalMs = opts.heartbeatIntervalMs) !== null && _opts_heartbeatIntervalMs !== void 0 ? _opts_heartbeatIntervalMs : _watchclaimts.WATCH_HEARTBEAT_INTERVAL_MS;
+                    if (!Number.isFinite(reconcileIntervalMs) || reconcileIntervalMs <= 0) throw new _errorsts.SenseError('CONFIG_INVALID', 'watch heartbeatIntervalMs must be a finite positive number');
+                    // Reconciliation may be parked for a caller, but live ownership must renew before fixed expiry.
+                    claimIntervalMs = Math.min(reconcileIntervalMs, _watchclaimts.WATCH_HEARTBEAT_INTERVAL_MS);
                     rootDir = (_cfg_rootDir = cfg.rootDir) !== null && _cfg_rootDir !== void 0 ? _cfg_rootDir : cfg.baseDir;
+                    configDir = (_cfg_configDir = cfg.configDir) !== null && _cfg_configDir !== void 0 ? _cfg_configDir : rootDir;
+                    claimFailure = null;
                     return [
                         4,
-                        (0, _indexts1.getMeta)(initialStore, 'watch_heartbeat')
+                        (0, _watchclaimts.startWatchClaim)(configDir, (_opts_force = opts.force) !== null && _opts_force !== void 0 ? _opts_force : false, claimIntervalMs, function(err) {
+                            claimFailure !== null && claimFailure !== void 0 ? claimFailure : claimFailure = err;
+                            requestShutdown === null || requestShutdown === void 0 ? void 0 : requestShutdown(err);
+                        })
                     ];
+                case 1:
+                    claim = _state.sent();
+                    claimCloseStarted = false;
+                    closeClaim = function closeClaim() {
+                        claimCloseStarted = true;
+                        return claim.close();
+                    };
+                    _state.label = 2;
                 case 2:
-                    existingHeartbeat = _state.sent();
-                    if (!(existingHeartbeat && !opts.force)) return [
-                        3,
-                        4
-                    ];
-                    age = Date.now() - Date.parse(existingHeartbeat);
-                    if (!(age >= 0 && age < STALE_HEARTBEAT_MS)) return [
-                        3,
-                        4
-                    ];
+                    _state.trys.push([
+                        2,
+                        12,
+                        17,
+                        18
+                    ]);
                     return [
                         4,
-                        initialStore.close()
+                        (0, _indexts.openStore)(cfg)
                     ];
                 case 3:
-                    _state.sent();
-                    throw new _errorsts.SenseError('WATCH_ACTIVE', "another watcher appears active (heartbeat ".concat(Math.round(age / 1000), "s ago); use --force to override"));
+                    _ref = _state.sent(), initialStore = _ref.store, dbPath = _ref.dbPath, initialWarnings = _ref.warnings, initialParsed = _ref.parsed;
+                    initialTotal = 0;
+                    _state.label = 4;
                 case 4:
+                    _state.trys.push([
+                        4,
+                        ,
+                        8,
+                        10
+                    ]);
                     if (!(initialWarnings.length > 0 || initialParsed > 0)) return [
                         3,
                         6
                     ];
                     return [
                         4,
-                        (0, _indexts1.docCount)(initialStore)
+                        (0, _indexts.docCount)(initialStore)
                     ];
                 case 5:
                     _tmp = _state.sent();
@@ -202,38 +219,24 @@ function runWatch(_0) {
                     _tmp = 0;
                     _state.label = 7;
                 case 7:
+                    // total is read before close: an event fires only once nothing is held open again.
                     initialTotal = _tmp;
                     return [
-                        4,
-                        (0, _indexts1.setMeta)(initialStore, 'watch_heartbeat', new Date().toISOString())
+                        3,
+                        10
                     ];
                 case 8:
-                    _state.sent();
                     return [
                         4,
-                        (0, _indexts1.setMeta)(initialStore, 'watch_pid', String(process.pid))
+                        initialStore.close()
                     ];
                 case 9:
                     _state.sent();
                     return [
-                        4,
-                        initialStore.close()
+                        7
                     ];
                 case 10:
-                    _state.sent();
-                    onEvent({
-                        type: 'started',
-                        rootDir: rootDir,
-                        dbPath: dbPath
-                    });
-                    if (initialWarnings.length > 0 || initialParsed > 0) {
-                        onEvent({
-                            type: 'reconciled',
-                            parsed: initialParsed,
-                            total: initialTotal,
-                            warnings: initialWarnings
-                        });
-                    }
+                    if (claimFailure) throw claimFailure;
                     stopping = false;
                     // At most one open+reconcile+close cycle runs at a time; a trigger that arrives mid-cycle is
                     // coalesced into a single rerun instead of opening a second, overlapping connection.
@@ -247,13 +250,13 @@ function runWatch(_0) {
                                     case 0:
                                         _state.trys.push([
                                             0,
-                                            10,
+                                            8,
                                             ,
-                                            11
+                                            9
                                         ]);
                                         return [
                                             4,
-                                            (0, _indexts1.openStore)(cfg)
+                                            (0, _indexts.openStore)(cfg)
                                         ];
                                     case 1:
                                         _ref = _state.sent(), store = _ref.store, parsed = _ref.parsed, warnings = _ref.warnings;
@@ -262,24 +265,12 @@ function runWatch(_0) {
                                         _state.trys.push([
                                             2,
                                             ,
-                                            7,
-                                            9
+                                            5,
+                                            7
                                         ]);
-                                        return [
-                                            4,
-                                            (0, _indexts1.setMeta)(store, 'watch_heartbeat', new Date().toISOString())
-                                        ];
-                                    case 3:
-                                        _state.sent();
-                                        return [
-                                            4,
-                                            (0, _indexts1.setMeta)(store, 'watch_pid', String(process.pid))
-                                        ];
-                                    case 4:
-                                        _state.sent();
                                         if (!(alwaysEmit || parsed > 0 || warnings.length > 0)) return [
                                             3,
-                                            6
+                                            4
                                         ];
                                         _tmp = {
                                             type: 'reconciled',
@@ -287,34 +278,34 @@ function runWatch(_0) {
                                         };
                                         return [
                                             4,
-                                            (0, _indexts1.docCount)(store)
+                                            (0, _indexts.docCount)(store)
                                         ];
-                                    case 5:
+                                    case 3:
                                         onEvent.apply(void 0, [
                                             (_tmp.total = _state.sent(), _tmp.warnings = warnings, _tmp)
                                         ]);
-                                        _state.label = 6;
-                                    case 6:
+                                        _state.label = 4;
+                                    case 4:
                                         return [
                                             3,
-                                            9
+                                            7
                                         ];
-                                    case 7:
+                                    case 5:
                                         return [
                                             4,
                                             store.close()
                                         ];
-                                    case 8:
+                                    case 6:
                                         _state.sent();
                                         return [
                                             7
                                         ];
-                                    case 9:
+                                    case 7:
                                         return [
                                             3,
-                                            11
+                                            9
                                         ];
-                                    case 10:
+                                    case 8:
                                         err = _state.sent();
                                         onEvent({
                                             type: 'reconcile-error',
@@ -322,9 +313,9 @@ function runWatch(_0) {
                                         });
                                         return [
                                             3,
-                                            11
+                                            9
                                         ];
-                                    case 11:
+                                    case 9:
                                         return [
                                             2
                                         ];
@@ -358,15 +349,15 @@ function runWatch(_0) {
                             requestCycle(true);
                         }, debounceMs);
                     };
-                    // Ignore our own state dir, or the heartbeat write would retrigger itself forever. An event with
-                    // an unresolvable filename (null, which fs.watch delivers under load) reconciles: parsing nothing costs less than missing a real edit.
+                    // Ignore our own state files, or cache and claim writes would retrigger reconciliation forever.
+                    // An unresolvable filename reconciles because parsing nothing costs less than missing a real edit.
                     watcher = (0, _nodefs.watch)(rootDir, {
                         recursive: true
                     }, function(_event, filename) {
-                        if (typeof filename === 'string' && filename.startsWith(_indexts.STATE_DIR)) return;
+                        if (!(0, _watchnotificationts.shouldReconcileWatchNotification)(filename)) return;
                         scheduleReconcile();
                     });
-                    heartbeatTimer = setInterval((0, _guardedtickts.guardedTick)(function() {
+                    reconcileTimer = setInterval((0, _guardedtickts.guardedTick)(function() {
                         return _async_to_generator(function() {
                             return _ts_generator(this, function(_state) {
                                 return [
@@ -377,75 +368,183 @@ function runWatch(_0) {
                         })();
                     }, function() {
                         return stopping;
-                    }), heartbeatIntervalMs);
+                    }), reconcileIntervalMs);
                     return [
-                        2,
-                        new Promise(function(resolveShutdown) {
-                            var _opts_signal, _opts_signal1;
-                            // SIGINT/SIGTERM and an aborted signal all run this same path exactly once; each is
-                            // unregistered here too so a second runWatch call in the same process starts clean.
-                            var shutdown = function shutdown1() {
-                                return _async_to_generator(function() {
-                                    var _opts_signal, _ref, finalStore;
-                                    return _ts_generator(this, function(_state) {
-                                        switch(_state.label){
-                                            case 0:
-                                                if (stopping) return [
-                                                    2
-                                                ];
-                                                stopping = true;
-                                                process.off('SIGINT', shutdown);
-                                                process.off('SIGTERM', shutdown);
-                                                (_opts_signal = opts.signal) === null || _opts_signal === void 0 ? void 0 : _opts_signal.removeEventListener('abort', shutdown);
-                                                clearInterval(heartbeatTimer);
-                                                if (debounceTimer) clearTimeout(debounceTimer);
-                                                watcher.close();
-                                                return [
-                                                    4,
-                                                    running
-                                                ];
-                                            case 1:
-                                                _state.sent();
-                                                return [
-                                                    4,
-                                                    (0, _indexts1.openStore)(cfg)
-                                                ];
-                                            case 2:
-                                                _ref = _state.sent(), finalStore = _ref.store;
-                                                return [
-                                                    4,
-                                                    (0, _indexts1.setMeta)(finalStore, 'watch_heartbeat', null)
-                                                ];
-                                            case 3:
-                                                _state.sent();
-                                                return [
-                                                    4,
-                                                    (0, _indexts1.setMeta)(finalStore, 'watch_pid', null)
-                                                ];
-                                            case 4:
-                                                _state.sent();
-                                                return [
-                                                    4,
-                                                    finalStore.close()
-                                                ];
-                                            case 5:
-                                                _state.sent();
-                                                resolveShutdown();
-                                                return [
-                                                    2
-                                                ];
-                                        }
-                                    });
-                                })();
+                        4,
+                        new Promise(function(resolveShutdown, rejectShutdown) {
+                            var _opts_signal;
+                            var shutdownReason = null;
+                            var shutdown = function shutdown(reason) {
+                                shutdownReason !== null && shutdownReason !== void 0 ? shutdownReason : shutdownReason = reason !== null && reason !== void 0 ? reason : null;
+                                if (stopping) return;
+                                stopping = true;
+                                var shutdownTask = function() {
+                                    return _async_to_generator(function() {
+                                        var _opts_signal, finalError, _ref, finalStore, err, err1;
+                                        return _ts_generator(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    process.off('SIGINT', stopNormally);
+                                                    process.off('SIGTERM', stopNormally);
+                                                    (_opts_signal = opts.signal) === null || _opts_signal === void 0 ? void 0 : _opts_signal.removeEventListener('abort', stopNormally);
+                                                    clearInterval(reconcileTimer);
+                                                    if (debounceTimer) clearTimeout(debounceTimer);
+                                                    watcher.close();
+                                                    return [
+                                                        4,
+                                                        running
+                                                    ];
+                                                case 1:
+                                                    _state.sent();
+                                                    _state.label = 2;
+                                                case 2:
+                                                    _state.trys.push([
+                                                        2,
+                                                        6,
+                                                        ,
+                                                        7
+                                                    ]);
+                                                    if (!!shutdownReason) return [
+                                                        3,
+                                                        5
+                                                    ];
+                                                    return [
+                                                        4,
+                                                        (0, _indexts.openStore)(cfg)
+                                                    ];
+                                                case 3:
+                                                    _ref = _state.sent(), finalStore = _ref.store;
+                                                    return [
+                                                        4,
+                                                        finalStore.close()
+                                                    ];
+                                                case 4:
+                                                    _state.sent();
+                                                    _state.label = 5;
+                                                case 5:
+                                                    return [
+                                                        3,
+                                                        7
+                                                    ];
+                                                case 6:
+                                                    err = _state.sent();
+                                                    finalError = err;
+                                                    return [
+                                                        3,
+                                                        7
+                                                    ];
+                                                case 7:
+                                                    _state.trys.push([
+                                                        7,
+                                                        9,
+                                                        ,
+                                                        10
+                                                    ]);
+                                                    return [
+                                                        4,
+                                                        closeClaim()
+                                                    ];
+                                                case 8:
+                                                    _state.sent();
+                                                    return [
+                                                        3,
+                                                        10
+                                                    ];
+                                                case 9:
+                                                    err1 = _state.sent();
+                                                    if (finalError) throw new AggregateError([
+                                                        finalError,
+                                                        err1
+                                                    ], 'watch shutdown and claim cleanup both failed');
+                                                    throw err1;
+                                                case 10:
+                                                    if (finalError) throw finalError;
+                                                    if (shutdownReason) throw shutdownReason;
+                                                    return [
+                                                        2
+                                                    ];
+                                            }
+                                        });
+                                    })();
+                                }();
+                                shutdownTask.then(resolveShutdown, rejectShutdown);
                             };
-                            process.once('SIGINT', shutdown);
-                            process.once('SIGTERM', shutdown);
-                            if ((_opts_signal = opts.signal) === null || _opts_signal === void 0 ? void 0 : _opts_signal.aborted) shutdown();
-                            else (_opts_signal1 = opts.signal) === null || _opts_signal1 === void 0 ? void 0 : _opts_signal1.addEventListener('abort', shutdown, {
-                                once: true
-                            });
+                            var stopNormally = function stopNormally() {
+                                return shutdown();
+                            };
+                            requestShutdown = shutdown;
+                            process.once('SIGINT', stopNormally);
+                            process.once('SIGTERM', stopNormally);
+                            if (claimFailure) shutdown(claimFailure);
+                            else if ((_opts_signal = opts.signal) === null || _opts_signal === void 0 ? void 0 : _opts_signal.aborted) shutdown();
+                            else {
+                                var _opts_signal1;
+                                (_opts_signal1 = opts.signal) === null || _opts_signal1 === void 0 ? void 0 : _opts_signal1.addEventListener('abort', stopNormally, {
+                                    once: true
+                                });
+                                try {
+                                    onEvent({
+                                        type: 'started',
+                                        rootDir: rootDir,
+                                        dbPath: dbPath
+                                    });
+                                    if (!stopping && (initialWarnings.length > 0 || initialParsed > 0)) {
+                                        onEvent({
+                                            type: 'reconciled',
+                                            parsed: initialParsed,
+                                            total: initialTotal,
+                                            warnings: initialWarnings
+                                        });
+                                    }
+                                } catch (err) {
+                                    shutdown(_instanceof(err, Error) ? err : new Error(String(err)));
+                                }
+                            }
                         })
                     ];
+                case 11:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+                case 12:
+                    err = _state.sent();
+                    if (claimCloseStarted) throw err;
+                    _state.label = 13;
+                case 13:
+                    _state.trys.push([
+                        13,
+                        15,
+                        ,
+                        16
+                    ]);
+                    return [
+                        4,
+                        closeClaim()
+                    ];
+                case 14:
+                    _state.sent();
+                    return [
+                        3,
+                        16
+                    ];
+                case 15:
+                    closeError = _state.sent();
+                    throw new AggregateError([
+                        err,
+                        closeError
+                    ], 'watch setup and claim cleanup both failed');
+                case 16:
+                    throw err;
+                case 17:
+                    requestShutdown = undefined;
+                    return [
+                        7
+                    ];
+                case 18:
+                    return [
+                        2
+                    ];
             }
         });
     }).apply(this, arguments);

package/dist/cjs/watch.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/watch.ts"],"sourcesContent":["import { watch as fsWatch } from 'node:fs';\nimport type { ResolvedConfig } from './config/index.ts';\nimport { STATE_DIR } from './config/index.ts';\nimport { SenseError } from './errors.ts';\nimport { guardedTick } from './lib/guarded-tick.ts';\nimport { docCount, getMeta, openStore, setMeta } from './store/index.ts';\n\n// Watch is a cache pre-warmer, not a correctness mechanism: open() always reconciles anyway, so any fs event just triggers a debounced full reconcile.\nconst DEBOUNCE_MS = 200;\nconst HEARTBEAT_INTERVAL_MS = 5000;\nconst STALE_HEARTBEAT_MS = 15000;\n\nexport type WatchEvent = { type: 'started'; rootDir: string; dbPath: string } | { type: 'reconciled'; parsed: number; total: number; warnings: string[] } | { type: 'reconcile-error'; message: string };\n\nexport interface WatchOptions {\n  force?: boolean;\n  onEvent?: (event: WatchEvent) => void;\n  // Aborting runs the same shutdown path as SIGINT/SIGTERM.\n  signal?: AbortSignal;\n  debounceMs?: number;\n  heartbeatIntervalMs?: number;\n}\n\n// Runs in the foreground until SIGINT/SIGTERM/signal abort. duckdb/turso hand the cache file to\n// one process at a time, so every cycle opens, reconciles, writes the heartbeat/pid rows, and closes.\nexport async function runWatch(cfg: ResolvedConfig, opts: WatchOptions = {}): Promise<void> {\n  const onEvent = opts.onEvent ?? (() => {});\n  const debounceMs = opts.debounceMs ?? DEBOUNCE_MS;\n  const heartbeatIntervalMs = opts.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS;\n  const { store: initialStore, dbPath, warnings: initialWarnings, parsed: initialParsed } = await openStore(cfg);\n  // openStore normalizes the legacy direct-API baseDir before a watcher touches the filesystem.\n  const rootDir = cfg.rootDir ?? cfg.baseDir;\n  const existingHeartbeat = await getMeta(initialStore, 'watch_heartbeat');\n  if (existingHeartbeat && !opts.force) {\n    const age = Date.now() - Date.parse(existingHeartbeat);\n    if (age >= 0 && age < STALE_HEARTBEAT_MS) {\n      await initialStore.close();\n      throw new SenseError('WATCH_ACTIVE', `another watcher appears active (heartbeat ${Math.round(age / 1000)}s ago); use --force to override`);\n    }\n  }\n\n  // total is read before close: an event fires only once nothing is held open again.\n  const initialTotal = initialWarnings.length > 0 || initialParsed > 0 ? await docCount(initialStore) : 0;\n  await setMeta(initialStore, 'watch_heartbeat', new Date().toISOString());\n  await setMeta(initialStore, 'watch_pid', String(process.pid));\n  await initialStore.close();\n\n  onEvent({ type: 'started', rootDir, dbPath });\n  if (initialWarnings.length > 0 || initialParsed > 0) {\n    onEvent({ type: 'reconciled', parsed: initialParsed, total: initialTotal, warnings: initialWarnings });\n  }\n\n  let stopping = false;\n  // At most one open+reconcile+close cycle runs at a time; a trigger that arrives mid-cycle is\n  // coalesced into a single rerun instead of opening a second, overlapping connection.\n  let running: Promise<void> | null = null;\n  let queuedAlways: boolean | null = null;\n\n  const tick = async (alwaysEmit: boolean): Promise<void> => {\n    try {\n      const { store, parsed, warnings } = await openStore(cfg);\n      try {\n        await setMeta(store, 'watch_heartbeat', new Date().toISOString());\n        await setMeta(store, 'watch_pid', String(process.pid));\n        if (alwaysEmit || parsed > 0 || warnings.length > 0) {\n          onEvent({ type: 'reconciled', parsed, total: await docCount(store), warnings });\n        }\n      } finally {\n        await store.close();\n      }\n    } catch (err) {\n      onEvent({ type: 'reconcile-error', message: (err as Error).message });\n    }\n  };\n\n  const startCycle = (alwaysEmit: boolean) => {\n    running = tick(alwaysEmit).then(() => {\n      running = null;\n      if (queuedAlways !== null && !stopping) {\n        const again = queuedAlways;\n        queuedAlways = null;\n        startCycle(again);\n      }\n    });\n  };\n\n  const requestCycle = (alwaysEmit: boolean) => {\n    if (stopping) return;\n    if (running) {\n      queuedAlways = queuedAlways || alwaysEmit;\n      return;\n    }\n    startCycle(alwaysEmit);\n  };\n\n  let debounceTimer: NodeJS.Timeout | null = null;\n  const scheduleReconcile = () => {\n    if (debounceTimer) clearTimeout(debounceTimer);\n    debounceTimer = setTimeout(() => {\n      debounceTimer = null;\n      requestCycle(true);\n    }, debounceMs);\n  };\n\n  // Ignore our own state dir, or the heartbeat write would retrigger itself forever. An event with\n  // an unresolvable filename (null, which fs.watch delivers under load) reconciles: parsing nothing costs less than missing a real edit.\n  const watcher = fsWatch(rootDir, { recursive: true }, (_event, filename) => {\n    if (typeof filename === 'string' && filename.startsWith(STATE_DIR)) return;\n    scheduleReconcile();\n  });\n  const heartbeatTimer = setInterval(\n    guardedTick(\n      async () => requestCycle(false),\n      () => stopping\n    ),\n    heartbeatIntervalMs\n  );\n\n  return new Promise<void>((resolveShutdown) => {\n    // SIGINT/SIGTERM and an aborted signal all run this same path exactly once; each is\n    // unregistered here too so a second runWatch call in the same process starts clean.\n    const shutdown = async () => {\n      if (stopping) return;\n      stopping = true;\n      process.off('SIGINT', shutdown);\n      process.off('SIGTERM', shutdown);\n      opts.signal?.removeEventListener('abort', shutdown);\n      clearInterval(heartbeatTimer);\n      if (debounceTimer) clearTimeout(debounceTimer);\n      watcher.close();\n      await running;\n      const { store: finalStore } = await openStore(cfg);\n      await setMeta(finalStore, 'watch_heartbeat', null);\n      await setMeta(finalStore, 'watch_pid', null);\n      await finalStore.close();\n      resolveShutdown();\n    };\n    process.once('SIGINT', shutdown);\n    process.once('SIGTERM', shutdown);\n    if (opts.signal?.aborted) shutdown();\n    else opts.signal?.addEventListener('abort', shutdown, { once: true });\n  });\n}\n"],"names":["runWatch","DEBOUNCE_MS","HEARTBEAT_INTERVAL_MS","STALE_HEARTBEAT_MS","cfg","opts","onEvent","debounceMs","heartbeatIntervalMs","initialStore","dbPath","initialWarnings","initialParsed","rootDir","existingHeartbeat","age","initialTotal","stopping","running","queuedAlways","tick","startCycle","requestCycle","debounceTimer","scheduleReconcile","watcher","heartbeatTimer","openStore","store","warnings","parsed","baseDir","getMeta","force","Date","now","parse","close","SenseError","Math","round","length","docCount","setMeta","toISOString","String","process","pid","type","total","alwaysEmit","err","message","then","again","clearTimeout","setTimeout","fsWatch","recursive","_event","filename","startsWith","STATE_DIR","setInterval","guardedTick","Promise","resolveShutdown","shutdown","finalStore","off","signal","removeEventListener","clearInterval","once","aborted","addEventListener"],"mappings":";;;;+BAyBsBA;;;eAAAA;;;sBAzBW;uBAEP;wBACC;6BACC;wBAC0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtD,uJAAuJ;AACvJ,IAAMC,cAAc;AACpB,IAAMC,wBAAwB;AAC9B,IAAMC,qBAAqB;AAepB,SAAeH;wCAASI,GAAmB;YAAEC,MAClCA,eACGA,kBACSA,2BAGZD,cALVE,SACAC,YACAC,qBACoF,MAA3EC,cAAcC,QAAkBC,iBAAyBC,eAElEC,SACAC,mBAEEC,KAQFC,oBAUFC,UAGAC,SACAC,cAEEC,MAiBAC,YAWAC,cASFC,eACEC,mBAUAC,SAIAC;;;;;oBArF4CrB,OAAAA,oEAAqB,CAAC;oBAClEC,WAAUD,gBAAAA,KAAKC,OAAO,cAAZD,2BAAAA,gBAAiB,YAAO;oBAClCE,cAAaF,mBAAAA,KAAKE,UAAU,cAAfF,8BAAAA,mBAAmBJ;oBAChCO,uBAAsBH,4BAAAA,KAAKG,mBAAmB,cAAxBH,uCAAAA,4BAA4BH;oBACkC;;wBAAMyB,IAAAA,mBAAS,EAACvB;;;oBAAhB,OAAA,eAA3EK,eAA2E,KAAlFmB,OAAqBlB,SAA6D,KAA7DA,QAAkBC,kBAA2C,KAArDkB,UAAmCjB,gBAAkB,KAA1BkB;oBAChE,8FAA8F;oBACxFjB,WAAUT,eAAAA,IAAIS,OAAO,cAAXT,0BAAAA,eAAeA,IAAI2B,OAAO;oBAChB;;wBAAMC,IAAAA,iBAAO,EAACvB,cAAc;;;oBAAhDK,oBAAoB;yBACtBA,CAAAA,qBAAqB,CAACT,KAAK4B,KAAK,AAAD,GAA/BnB;;;;oBACIC,MAAMmB,KAAKC,GAAG,KAAKD,KAAKE,KAAK,CAACtB;yBAChCC,CAAAA,OAAO,KAAKA,MAAMZ,kBAAiB,GAAnCY;;;;oBACF;;wBAAMN,aAAa4B,KAAK;;;oBAAxB;oBACA,MAAM,IAAIC,oBAAU,CAAC,gBAAgB,AAAC,6CAAmE,OAAvBC,KAAKC,KAAK,CAACzB,MAAM,OAAM;;yBAKxFJ,CAAAA,gBAAgB8B,MAAM,GAAG,KAAK7B,gBAAgB,CAAA,GAA9CD;;;;oBAAkD;;wBAAM+B,IAAAA,kBAAQ,EAACjC;;;2BAAf;;;;;;2BAA+B;;;oBAAhGO;oBACN;;wBAAM2B,IAAAA,iBAAO,EAAClC,cAAc,mBAAmB,IAAIyB,OAAOU,WAAW;;;oBAArE;oBACA;;wBAAMD,IAAAA,iBAAO,EAAClC,cAAc,aAAaoC,OAAOC,QAAQC,GAAG;;;oBAA3D;oBACA;;wBAAMtC,aAAa4B,KAAK;;;oBAAxB;oBAEA/B,QAAQ;wBAAE0C,MAAM;wBAAWnC,SAAAA;wBAASH,QAAAA;oBAAO;oBAC3C,IAAIC,gBAAgB8B,MAAM,GAAG,KAAK7B,gBAAgB,GAAG;wBACnDN,QAAQ;4BAAE0C,MAAM;4BAAclB,QAAQlB;4BAAeqC,OAAOjC;4BAAca,UAAUlB;wBAAgB;oBACtG;oBAEIM,WAAW;oBACf,6FAA6F;oBAC7F,qFAAqF;oBACjFC,UAAgC;oBAChCC,eAA+B;oBAE7BC,OAAO,cAAO8B;;gCAEoB,MAA5BtB,OAAOE,QAAQD,gBAUhBsB;;;;;;;;;;wCAV6B;;4CAAMxB,IAAAA,mBAAS,EAACvB;;;wCAAhB,OAAA,eAA5BwB,QAA4B,KAA5BA,OAAOE,SAAqB,KAArBA,QAAQD,WAAa,KAAbA;;;;;;;;;wCAErB;;4CAAMc,IAAAA,iBAAO,EAACf,OAAO,mBAAmB,IAAIM,OAAOU,WAAW;;;wCAA9D;wCACA;;4CAAMD,IAAAA,iBAAO,EAACf,OAAO,aAAaiB,OAAOC,QAAQC,GAAG;;;wCAApD;6CACIG,CAAAA,cAAcpB,SAAS,KAAKD,SAASY,MAAM,GAAG,CAAA,GAA9CS;;;;;4CACQF,MAAM;4CAAclB,QAAAA;;wCAAe;;4CAAMY,IAAAA,kBAAQ,EAACd;;;wCAA5DtB;kDAAsC2C,QAAO,oBAAuBpB,WAAAA;;;;;;;;;wCAGtE;;4CAAMD,MAAMS,KAAK;;;wCAAjB;;;;;;;;;;wCAEKc;wCACP7C,QAAQ;4CAAE0C,MAAM;4CAAmBI,SAAS,AAACD,IAAcC,OAAO;wCAAC;;;;;;;;;;;wBAEvE;;oBAEM/B,aAAa,qBAAC6B;wBAClBhC,UAAUE,KAAK8B,YAAYG,IAAI,CAAC;4BAC9BnC,UAAU;4BACV,IAAIC,iBAAiB,QAAQ,CAACF,UAAU;gCACtC,IAAMqC,QAAQnC;gCACdA,eAAe;gCACfE,WAAWiC;4BACb;wBACF;oBACF;oBAEMhC,eAAe,sBAAC4B;wBACpB,IAAIjC,UAAU;wBACd,IAAIC,SAAS;4BACXC,eAAeA,gBAAgB+B;4BAC/B;wBACF;wBACA7B,WAAW6B;oBACb;oBAEI3B,gBAAuC;oBACrCC,oBAAoB;wBACxB,IAAID,eAAegC,aAAahC;wBAChCA,gBAAgBiC,WAAW;4BACzBjC,gBAAgB;4BAChBD,aAAa;wBACf,GAAGf;oBACL;oBAEA,iGAAiG;oBACjG,uIAAuI;oBACjIkB,UAAUgC,IAAAA,aAAO,EAAC5C,SAAS;wBAAE6C,WAAW;oBAAK,GAAG,SAACC,QAAQC;wBAC7D,IAAI,OAAOA,aAAa,YAAYA,SAASC,UAAU,CAACC,kBAAS,GAAG;wBACpEtC;oBACF;oBACME,iBAAiBqC,YACrBC,IAAAA,0BAAW,EACT;;;;;oCAAY1C,aAAa;;;;uBACzB;+BAAML;wBAERT;oBAGF;;wBAAO,IAAIyD,QAAc,SAACC;gCAqBpB7D,cACCA;4BArBL,oFAAoF;4BACpF,oFAAoF;4BACpF,IAAM8D,WAAW;;wCAKf9D,cAK8B,MAAf+D;;;;gDATf,IAAInD,UAAU;;;gDACdA,WAAW;gDACX6B,QAAQuB,GAAG,CAAC,UAAUF;gDACtBrB,QAAQuB,GAAG,CAAC,WAAWF;iDACvB9D,eAAAA,KAAKiE,MAAM,cAAXjE,mCAAAA,aAAakE,mBAAmB,CAAC,SAASJ;gDAC1CK,cAAc9C;gDACd,IAAIH,eAAegC,aAAahC;gDAChCE,QAAQY,KAAK;gDACb;;oDAAMnB;;;gDAAN;gDAC8B;;oDAAMS,IAAAA,mBAAS,EAACvB;;;gDAAhB,OAAA,eAAfgE,aAAe,KAAtBxC;gDACR;;oDAAMe,IAAAA,iBAAO,EAACyB,YAAY,mBAAmB;;;gDAA7C;gDACA;;oDAAMzB,IAAAA,iBAAO,EAACyB,YAAY,aAAa;;;gDAAvC;gDACA;;oDAAMA,WAAW/B,KAAK;;;gDAAtB;gDACA6B;;;;;;gCACF;;4BACApB,QAAQ2B,IAAI,CAAC,UAAUN;4BACvBrB,QAAQ2B,IAAI,CAAC,WAAWN;4BACxB,KAAI9D,eAAAA,KAAKiE,MAAM,cAAXjE,mCAAAA,aAAaqE,OAAO,EAAEP;kCACrB9D,gBAAAA,KAAKiE,MAAM,cAAXjE,oCAAAA,cAAasE,gBAAgB,CAAC,SAASR,UAAU;gCAAEM,MAAM;4BAAK;wBACrE;;;;IACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/watch.ts"],"sourcesContent":["import { watch as fsWatch } from 'node:fs';\nimport type { ResolvedConfig } from './config/index.ts';\nimport { SenseError } from './errors.ts';\nimport { guardedTick } from './lib/guarded-tick.ts';\nimport { shouldReconcileWatchNotification } from './lib/watch-notification.ts';\nimport { docCount, openStore } from './store/index.ts';\nimport { startWatchClaim, WATCH_HEARTBEAT_INTERVAL_MS } from './watch-claim.ts';\n\n// Watch is a cache pre-warmer, not a correctness mechanism: open() always reconciles anyway, so any fs event just triggers a debounced full reconcile.\nconst DEBOUNCE_MS = 200;\n\nexport type WatchEvent = { type: 'started'; rootDir: string; dbPath: string } | { type: 'reconciled'; parsed: number; total: number; warnings: string[] } | { type: 'reconcile-error'; message: string };\n\nexport interface WatchOptions {\n  force?: boolean;\n  onEvent?: (event: WatchEvent) => void;\n  // Aborting runs the same shutdown path as SIGINT/SIGTERM.\n  signal?: AbortSignal;\n  debounceMs?: number;\n  heartbeatIntervalMs?: number;\n}\n\n// Runs in the foreground until SIGINT/SIGTERM/signal abort. DuckDB and Turso hand the cache file to\n// one process at a time, so every reconcile cycle opens and closes instead of holding an idle lock.\nexport async function runWatch(cfg: ResolvedConfig, opts: WatchOptions = {}): Promise<void> {\n  const onEvent = opts.onEvent ?? (() => {});\n  const debounceMs = opts.debounceMs ?? DEBOUNCE_MS;\n  const reconcileIntervalMs = opts.heartbeatIntervalMs ?? WATCH_HEARTBEAT_INTERVAL_MS;\n  if (!Number.isFinite(reconcileIntervalMs) || reconcileIntervalMs <= 0) throw new SenseError('CONFIG_INVALID', 'watch heartbeatIntervalMs must be a finite positive number');\n  // Reconciliation may be parked for a caller, but live ownership must renew before fixed expiry.\n  const claimIntervalMs = Math.min(reconcileIntervalMs, WATCH_HEARTBEAT_INTERVAL_MS);\n  const rootDir = cfg.rootDir ?? cfg.baseDir;\n  const configDir = cfg.configDir ?? rootDir;\n  let claimFailure: Error | null = null;\n  let requestShutdown: ((reason: Error) => void) | undefined;\n  const claim = await startWatchClaim(configDir, opts.force ?? false, claimIntervalMs, (err) => {\n    claimFailure ??= err;\n    requestShutdown?.(err);\n  });\n  let claimCloseStarted = false;\n  const closeClaim = (): Promise<void> => {\n    claimCloseStarted = true;\n    return claim.close();\n  };\n  try {\n    const { store: initialStore, dbPath, warnings: initialWarnings, parsed: initialParsed } = await openStore(cfg);\n    let initialTotal = 0;\n    try {\n      // total is read before close: an event fires only once nothing is held open again.\n      initialTotal = initialWarnings.length > 0 || initialParsed > 0 ? await docCount(initialStore) : 0;\n    } finally {\n      await initialStore.close();\n    }\n    if (claimFailure) throw claimFailure;\n\n    let stopping = false;\n    // At most one open+reconcile+close cycle runs at a time; a trigger that arrives mid-cycle is\n    // coalesced into a single rerun instead of opening a second, overlapping connection.\n    let running: Promise<void> | null = null;\n    let queuedAlways: boolean | null = null;\n\n    const tick = async (alwaysEmit: boolean): Promise<void> => {\n      try {\n        const { store, parsed, warnings } = await openStore(cfg);\n        try {\n          if (alwaysEmit || parsed > 0 || warnings.length > 0) {\n            onEvent({ type: 'reconciled', parsed, total: await docCount(store), warnings });\n          }\n        } finally {\n          await store.close();\n        }\n      } catch (err) {\n        onEvent({ type: 'reconcile-error', message: (err as Error).message });\n      }\n    };\n\n    const startCycle = (alwaysEmit: boolean) => {\n      running = tick(alwaysEmit).then(() => {\n        running = null;\n        if (queuedAlways !== null && !stopping) {\n          const again = queuedAlways;\n          queuedAlways = null;\n          startCycle(again);\n        }\n      });\n    };\n\n    const requestCycle = (alwaysEmit: boolean) => {\n      if (stopping) return;\n      if (running) {\n        queuedAlways = queuedAlways || alwaysEmit;\n        return;\n      }\n      startCycle(alwaysEmit);\n    };\n\n    let debounceTimer: NodeJS.Timeout | null = null;\n    const scheduleReconcile = () => {\n      if (debounceTimer) clearTimeout(debounceTimer);\n      debounceTimer = setTimeout(() => {\n        debounceTimer = null;\n        requestCycle(true);\n      }, debounceMs);\n    };\n\n    // Ignore our own state files, or cache and claim writes would retrigger reconciliation forever.\n    // An unresolvable filename reconciles because parsing nothing costs less than missing a real edit.\n    const watcher = fsWatch(rootDir, { recursive: true }, (_event, filename) => {\n      if (!shouldReconcileWatchNotification(filename)) return;\n      scheduleReconcile();\n    });\n    const reconcileTimer = setInterval(\n      guardedTick(\n        async () => requestCycle(false),\n        () => stopping\n      ),\n      reconcileIntervalMs\n    );\n\n    return await new Promise<void>((resolveShutdown, rejectShutdown) => {\n      let shutdownReason: Error | null = null;\n      const shutdown = (reason?: Error) => {\n        shutdownReason ??= reason ?? null;\n        if (stopping) return;\n        stopping = true;\n        const shutdownTask = (async () => {\n          process.off('SIGINT', stopNormally);\n          process.off('SIGTERM', stopNormally);\n          opts.signal?.removeEventListener('abort', stopNormally);\n          clearInterval(reconcileTimer);\n          if (debounceTimer) clearTimeout(debounceTimer);\n          watcher.close();\n          await running;\n          let finalError: unknown;\n          try {\n            // A normal stop performs one final freshness pass. Ownership loss drains existing work\n            // but starts nothing new because the replacement watcher now owns that responsibility.\n            if (!shutdownReason) {\n              const { store: finalStore } = await openStore(cfg);\n              await finalStore.close();\n            }\n          } catch (err) {\n            finalError = err;\n          }\n          try {\n            await closeClaim();\n          } catch (err) {\n            if (finalError) throw new AggregateError([finalError, err], 'watch shutdown and claim cleanup both failed');\n            throw err;\n          }\n          if (finalError) throw finalError;\n          if (shutdownReason) throw shutdownReason;\n        })();\n        shutdownTask.then(resolveShutdown, rejectShutdown);\n      };\n      const stopNormally = () => shutdown();\n      requestShutdown = shutdown;\n      process.once('SIGINT', stopNormally);\n      process.once('SIGTERM', stopNormally);\n      if (claimFailure) shutdown(claimFailure);\n      else if (opts.signal?.aborted) shutdown();\n      else {\n        opts.signal?.addEventListener('abort', stopNormally, { once: true });\n        try {\n          onEvent({ type: 'started', rootDir, dbPath });\n          if (!stopping && (initialWarnings.length > 0 || initialParsed > 0)) {\n            onEvent({ type: 'reconciled', parsed: initialParsed, total: initialTotal, warnings: initialWarnings });\n          }\n        } catch (err) {\n          shutdown(err instanceof Error ? err : new Error(String(err)));\n        }\n      }\n    });\n  } catch (err) {\n    if (claimCloseStarted) throw err;\n    try {\n      await closeClaim();\n    } catch (closeError) {\n      throw new AggregateError([err, closeError], 'watch setup and claim cleanup both failed');\n    }\n    throw err;\n  } finally {\n    requestShutdown = undefined;\n  }\n}\n"],"names":["runWatch","DEBOUNCE_MS","cfg","opts","onEvent","debounceMs","reconcileIntervalMs","claimIntervalMs","rootDir","configDir","claimFailure","requestShutdown","claim","claimCloseStarted","closeClaim","initialStore","dbPath","initialWarnings","initialParsed","initialTotal","stopping","running","queuedAlways","tick","startCycle","requestCycle","debounceTimer","scheduleReconcile","watcher","reconcileTimer","err","closeError","heartbeatIntervalMs","WATCH_HEARTBEAT_INTERVAL_MS","Number","isFinite","SenseError","Math","min","baseDir","startWatchClaim","force","close","openStore","store","warnings","parsed","length","docCount","alwaysEmit","type","total","message","then","again","clearTimeout","setTimeout","fsWatch","recursive","_event","filename","shouldReconcileWatchNotification","setInterval","guardedTick","Promise","resolveShutdown","rejectShutdown","shutdownReason","shutdown","reason","shutdownTask","finalError","finalStore","process","off","stopNormally","signal","removeEventListener","clearInterval","AggregateError","once","aborted","addEventListener","Error","String","undefined"],"mappings":"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"}

package/dist/cjs/workers/watch-heartbeat.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/workers/watch-heartbeat.d.ts

@@ -0,0 +1 @@
+export {};