sensemaking 0.24.3 → 0.24.5

package/dist/esm/watch.js

@@ -2,137 +2,188 @@ import { watch as fsWatch } from 'node:fs';
 import { STATE_DIR } from './config/index.js';
 import { SenseError } from './errors.js';
 import { guardedTick } from './lib/guarded-tick.js';
-import { docCount, getMeta, openStore, setMeta } from './store/index.js';
+import { docCount, openStore } from './store/index.js';
+import { startWatchClaim, WATCH_HEARTBEAT_INTERVAL_MS } from './watch-claim.js';
 // Watch is a cache pre-warmer, not a correctness mechanism: open() always reconciles anyway, so any fs event just triggers a debounced full reconcile.
 const DEBOUNCE_MS = 200;
-const HEARTBEAT_INTERVAL_MS = 5000;
-const STALE_HEARTBEAT_MS = 15000;
-// Runs in the foreground until SIGINT/SIGTERM/signal abort. duckdb/turso hand the cache file to
-// one process at a time, so every cycle opens, reconciles, writes the heartbeat/pid rows, and closes.
+// Runs in the foreground until SIGINT/SIGTERM/signal abort. DuckDB and Turso hand the cache file to
+// one process at a time, so every reconcile cycle opens and closes instead of holding an idle lock.
 export async function runWatch(cfg, opts = {}) {
-    var _opts_onEvent, _opts_debounceMs, _opts_heartbeatIntervalMs, _cfg_rootDir;
+    var _opts_onEvent, _opts_debounceMs, _opts_heartbeatIntervalMs, _cfg_rootDir, _cfg_configDir, _opts_force;
     const onEvent = (_opts_onEvent = opts.onEvent) !== null && _opts_onEvent !== void 0 ? _opts_onEvent : ()=>{};
     const debounceMs = (_opts_debounceMs = opts.debounceMs) !== null && _opts_debounceMs !== void 0 ? _opts_debounceMs : DEBOUNCE_MS;
-    const heartbeatIntervalMs = (_opts_heartbeatIntervalMs = opts.heartbeatIntervalMs) !== null && _opts_heartbeatIntervalMs !== void 0 ? _opts_heartbeatIntervalMs : HEARTBEAT_INTERVAL_MS;
-    const { store: initialStore, dbPath, warnings: initialWarnings, parsed: initialParsed } = await openStore(cfg);
-    // openStore normalizes the legacy direct-API baseDir before a watcher touches the filesystem.
+    const reconcileIntervalMs = (_opts_heartbeatIntervalMs = opts.heartbeatIntervalMs) !== null && _opts_heartbeatIntervalMs !== void 0 ? _opts_heartbeatIntervalMs : WATCH_HEARTBEAT_INTERVAL_MS;
+    if (!Number.isFinite(reconcileIntervalMs) || reconcileIntervalMs <= 0) throw new 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.
+    const claimIntervalMs = Math.min(reconcileIntervalMs, WATCH_HEARTBEAT_INTERVAL_MS);
     const rootDir = (_cfg_rootDir = cfg.rootDir) !== null && _cfg_rootDir !== void 0 ? _cfg_rootDir : cfg.baseDir;
-    const existingHeartbeat = await getMeta(initialStore, 'watch_heartbeat');
-    if (existingHeartbeat && !opts.force) {
-        const age = Date.now() - Date.parse(existingHeartbeat);
-        if (age >= 0 && age < STALE_HEARTBEAT_MS) {
-            await initialStore.close();
-            throw new SenseError('WATCH_ACTIVE', `another watcher appears active (heartbeat ${Math.round(age / 1000)}s ago); use --force to override`);
-        }
-    }
-    // total is read before close: an event fires only once nothing is held open again.
-    const initialTotal = initialWarnings.length > 0 || initialParsed > 0 ? await docCount(initialStore) : 0;
-    await setMeta(initialStore, 'watch_heartbeat', new Date().toISOString());
-    await setMeta(initialStore, 'watch_pid', String(process.pid));
-    await initialStore.close();
-    onEvent({
-        type: 'started',
-        rootDir,
-        dbPath
+    const configDir = (_cfg_configDir = cfg.configDir) !== null && _cfg_configDir !== void 0 ? _cfg_configDir : rootDir;
+    let claimFailure = null;
+    let requestShutdown;
+    const claim = await startWatchClaim(configDir, (_opts_force = opts.force) !== null && _opts_force !== void 0 ? _opts_force : false, claimIntervalMs, (err)=>{
+        claimFailure !== null && claimFailure !== void 0 ? claimFailure : claimFailure = err;
+        requestShutdown === null || requestShutdown === void 0 ? void 0 : requestShutdown(err);
     });
-    if (initialWarnings.length > 0 || initialParsed > 0) {
-        onEvent({
-            type: 'reconciled',
-            parsed: initialParsed,
-            total: initialTotal,
-            warnings: initialWarnings
-        });
-    }
-    let 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.
-    let running = null;
-    let queuedAlways = null;
-    const tick = async (alwaysEmit)=>{
+    let claimCloseStarted = false;
+    const closeClaim = ()=>{
+        claimCloseStarted = true;
+        return claim.close();
+    };
+    try {
+        const { store: initialStore, dbPath, warnings: initialWarnings, parsed: initialParsed } = await openStore(cfg);
+        let initialTotal = 0;
         try {
-            const { store, parsed, warnings } = await openStore(cfg);
+            // total is read before close: an event fires only once nothing is held open again.
+            initialTotal = initialWarnings.length > 0 || initialParsed > 0 ? await docCount(initialStore) : 0;
+        } finally{
+            await initialStore.close();
+        }
+        if (claimFailure) throw claimFailure;
+        let 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.
+        let running = null;
+        let queuedAlways = null;
+        const tick = async (alwaysEmit)=>{
             try {
-                await setMeta(store, 'watch_heartbeat', new Date().toISOString());
-                await setMeta(store, 'watch_pid', String(process.pid));
-                if (alwaysEmit || parsed > 0 || warnings.length > 0) {
-                    onEvent({
-                        type: 'reconciled',
-                        parsed,
-                        total: await docCount(store),
-                        warnings
-                    });
+                const { store, parsed, warnings } = await openStore(cfg);
+                try {
+                    if (alwaysEmit || parsed > 0 || warnings.length > 0) {
+                        onEvent({
+                            type: 'reconciled',
+                            parsed,
+                            total: await docCount(store),
+                            warnings
+                        });
+                    }
+                } finally{
+                    await store.close();
                 }
-            } finally{
-                await store.close();
+            } catch (err) {
+                onEvent({
+                    type: 'reconcile-error',
+                    message: err.message
+                });
             }
-        } catch (err) {
-            onEvent({
-                type: 'reconcile-error',
-                message: err.message
+        };
+        const startCycle = (alwaysEmit)=>{
+            running = tick(alwaysEmit).then(()=>{
+                running = null;
+                if (queuedAlways !== null && !stopping) {
+                    const again = queuedAlways;
+                    queuedAlways = null;
+                    startCycle(again);
+                }
             });
-        }
-    };
-    const startCycle = (alwaysEmit)=>{
-        running = tick(alwaysEmit).then(()=>{
-            running = null;
-            if (queuedAlways !== null && !stopping) {
-                const again = queuedAlways;
-                queuedAlways = null;
-                startCycle(again);
-            }
-        });
-    };
-    const requestCycle = (alwaysEmit)=>{
-        if (stopping) return;
-        if (running) {
-            queuedAlways = queuedAlways || alwaysEmit;
-            return;
-        }
-        startCycle(alwaysEmit);
-    };
-    let debounceTimer = null;
-    const scheduleReconcile = ()=>{
-        if (debounceTimer) clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(()=>{
-            debounceTimer = null;
-            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.
-    const watcher = fsWatch(rootDir, {
-        recursive: true
-    }, (_event, filename)=>{
-        if (typeof filename === 'string' && filename.startsWith(STATE_DIR)) return;
-        scheduleReconcile();
-    });
-    const heartbeatTimer = setInterval(guardedTick(async ()=>requestCycle(false), ()=>stopping), heartbeatIntervalMs);
-    return new Promise((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.
-        const shutdown = async ()=>{
-            var _opts_signal;
+        };
+        const requestCycle = (alwaysEmit)=>{
             if (stopping) return;
-            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 (running) {
+                queuedAlways = queuedAlways || alwaysEmit;
+                return;
+            }
+            startCycle(alwaysEmit);
+        };
+        let debounceTimer = null;
+        const scheduleReconcile = ()=>{
             if (debounceTimer) clearTimeout(debounceTimer);
-            watcher.close();
-            await running;
-            const { store: finalStore } = await openStore(cfg);
-            await setMeta(finalStore, 'watch_heartbeat', null);
-            await setMeta(finalStore, 'watch_pid', null);
-            await finalStore.close();
-            resolveShutdown();
+            debounceTimer = setTimeout(()=>{
+                debounceTimer = null;
+                requestCycle(true);
+            }, debounceMs);
         };
-        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
+        // 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.
+        const watcher = fsWatch(rootDir, {
+            recursive: true
+        }, (_event, filename)=>{
+            if (typeof filename === 'string' && filename.startsWith(STATE_DIR)) return;
+            scheduleReconcile();
         });
-    });
+        const reconcileTimer = setInterval(guardedTick(async ()=>requestCycle(false), ()=>stopping), reconcileIntervalMs);
+        return await new Promise((resolveShutdown, rejectShutdown)=>{
+            var _opts_signal;
+            let shutdownReason = null;
+            const shutdown = (reason)=>{
+                shutdownReason !== null && shutdownReason !== void 0 ? shutdownReason : shutdownReason = reason !== null && reason !== void 0 ? reason : null;
+                if (stopping) return;
+                stopping = true;
+                const shutdownTask = (async ()=>{
+                    var _opts_signal;
+                    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();
+                    await running;
+                    let finalError;
+                    try {
+                        // A normal stop performs one final freshness pass. Ownership loss drains existing work
+                        // but starts nothing new because the replacement watcher now owns that responsibility.
+                        if (!shutdownReason) {
+                            const { store: finalStore } = await openStore(cfg);
+                            await finalStore.close();
+                        }
+                    } catch (err) {
+                        finalError = err;
+                    }
+                    try {
+                        await closeClaim();
+                    } catch (err) {
+                        if (finalError) throw new AggregateError([
+                            finalError,
+                            err
+                        ], 'watch shutdown and claim cleanup both failed');
+                        throw err;
+                    }
+                    if (finalError) throw finalError;
+                    if (shutdownReason) throw shutdownReason;
+                })();
+                shutdownTask.then(resolveShutdown, rejectShutdown);
+            };
+            const stopNormally = ()=>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,
+                        dbPath
+                    });
+                    if (!stopping && (initialWarnings.length > 0 || initialParsed > 0)) {
+                        onEvent({
+                            type: 'reconciled',
+                            parsed: initialParsed,
+                            total: initialTotal,
+                            warnings: initialWarnings
+                        });
+                    }
+                } catch (err) {
+                    shutdown(err instanceof Error ? err : new Error(String(err)));
+                }
+            }
+        });
+    } catch (err) {
+        if (claimCloseStarted) throw err;
+        try {
+            await closeClaim();
+        } catch (closeError) {
+            throw new AggregateError([
+                err,
+                closeError
+            ], 'watch setup and claim cleanup both failed');
+        }
+        throw err;
+    } finally{
+        requestShutdown = undefined;
+    }
 }

package/dist/esm/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":["watch","fsWatch","STATE_DIR","SenseError","guardedTick","docCount","getMeta","openStore","setMeta","DEBOUNCE_MS","HEARTBEAT_INTERVAL_MS","STALE_HEARTBEAT_MS","runWatch","cfg","opts","onEvent","debounceMs","heartbeatIntervalMs","store","initialStore","dbPath","warnings","initialWarnings","parsed","initialParsed","rootDir","baseDir","existingHeartbeat","force","age","Date","now","parse","close","Math","round","initialTotal","length","toISOString","String","process","pid","type","total","stopping","running","queuedAlways","tick","alwaysEmit","err","message","startCycle","then","again","requestCycle","debounceTimer","scheduleReconcile","clearTimeout","setTimeout","watcher","recursive","_event","filename","startsWith","heartbeatTimer","setInterval","Promise","resolveShutdown","shutdown","off","signal","removeEventListener","clearInterval","finalStore","once","aborted","addEventListener"],"mappings":"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"}
+{"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, 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 (typeof filename === 'string' && filename.startsWith(STATE_DIR)) 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":["watch","fsWatch","STATE_DIR","SenseError","guardedTick","docCount","openStore","startWatchClaim","WATCH_HEARTBEAT_INTERVAL_MS","DEBOUNCE_MS","runWatch","cfg","opts","onEvent","debounceMs","reconcileIntervalMs","heartbeatIntervalMs","Number","isFinite","claimIntervalMs","Math","min","rootDir","baseDir","configDir","claimFailure","requestShutdown","claim","force","err","claimCloseStarted","closeClaim","close","store","initialStore","dbPath","warnings","initialWarnings","parsed","initialParsed","initialTotal","length","stopping","running","queuedAlways","tick","alwaysEmit","type","total","message","startCycle","then","again","requestCycle","debounceTimer","scheduleReconcile","clearTimeout","setTimeout","watcher","recursive","_event","filename","startsWith","reconcileTimer","setInterval","Promise","resolveShutdown","rejectShutdown","shutdownReason","shutdown","reason","shutdownTask","process","off","stopNormally","signal","removeEventListener","clearInterval","finalError","finalStore","AggregateError","once","aborted","addEventListener","Error","String","closeError","undefined"],"mappings":"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"}

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

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

package/dist/esm/workers/watch-heartbeat.js

@@ -0,0 +1,106 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { SenseError } from '../errors.js';
+import { serializeError } from '../scan/worker-error.js';
+import { WatchClaimDatabase } from '../watch-claim.js';
+function requireParentPort() {
+    const port = parentPort;
+    if (!port) throw new Error('watch heartbeat worker requires a parent port');
+    return port;
+}
+const port = requireParentPort();
+const data = workerData;
+let database;
+let timer;
+let stopping = false;
+let renewing = Promise.resolve();
+function send(message) {
+    port.postMessage(message);
+}
+function asError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+function closeDatabase() {
+    if (timer) clearInterval(timer);
+    timer = undefined;
+    try {
+        database === null || database === void 0 ? void 0 : database.close();
+        database = undefined;
+        return undefined;
+    } catch (err) {
+        return asError(err);
+    }
+}
+function addFailure(primary, secondary, message) {
+    return secondary ? new AggregateError([
+        primary,
+        secondary
+    ], message) : primary;
+}
+function fail(err) {
+    if (stopping) return;
+    stopping = true;
+    let failure = asError(err);
+    try {
+        database === null || database === void 0 ? void 0 : database.release(data.token);
+    } catch (releaseError) {
+        failure = addFailure(failure, asError(releaseError), 'watch heartbeat and claim release both failed');
+    }
+    const closeError = closeDatabase();
+    failure = addFailure(failure, closeError, 'watch heartbeat and database cleanup both failed');
+    try {
+        send({
+            type: 'failure',
+            error: serializeError(failure)
+        });
+    } finally{
+        port.close();
+    }
+}
+async function stop() {
+    if (stopping) return;
+    stopping = true;
+    if (timer) clearInterval(timer);
+    let failure;
+    try {
+        await renewing;
+        if (!(database === null || database === void 0 ? void 0 : database.release(data.token))) throw new SenseError('WATCH_ACTIVE', 'watch ownership was replaced by another watcher');
+    } catch (err) {
+        failure = asError(err);
+    } finally{
+        const closeError = closeDatabase();
+        if (closeError) failure = failure ? addFailure(failure, closeError, 'watch heartbeat shutdown and database cleanup both failed') : closeError;
+        try {
+            if (failure) send({
+                type: 'failure',
+                error: serializeError(failure)
+            });
+            else send({
+                type: 'stopped'
+            });
+        } finally{
+            port.close();
+        }
+    }
+}
+async function main() {
+    try {
+        database = new WatchClaimDatabase(data.configDir);
+        await database.acquire(data.token, data.pid, data.force);
+        send({
+            type: 'acquired'
+        });
+        timer = setInterval(()=>{
+            if (stopping) return;
+            renewing = renewing.then(()=>{
+                if (!(database === null || database === void 0 ? void 0 : database.renew(data.token))) throw new SenseError('WATCH_ACTIVE', 'watch ownership was replaced by another watcher');
+            });
+            renewing.catch(fail);
+        }, data.heartbeatIntervalMs);
+        port.on('message', (message)=>{
+            if (message.type === 'stop') void stop();
+        });
+    } catch (err) {
+        fail(err);
+    }
+}
+void main();

package/dist/esm/workers/watch-heartbeat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/workers/watch-heartbeat.ts"],"sourcesContent":["import { parentPort, workerData } from 'node:worker_threads';\nimport { SenseError } from '../errors.ts';\nimport { serializeError } from '../scan/worker-error.ts';\nimport { WatchClaimDatabase, type WatchClaimWorkerData, type WatchClaimWorkerMessage } from '../watch-claim.ts';\n\nfunction requireParentPort() {\n  const port = parentPort;\n  if (!port) throw new Error('watch heartbeat worker requires a parent port');\n  return port;\n}\n\nconst port = requireParentPort();\nconst data = workerData as WatchClaimWorkerData;\nlet database: WatchClaimDatabase | undefined;\nlet timer: NodeJS.Timeout | undefined;\nlet stopping = false;\nlet renewing = Promise.resolve();\n\nfunction send(message: WatchClaimWorkerMessage): void {\n  port.postMessage(message);\n}\n\nfunction asError(value: unknown): Error {\n  return value instanceof Error ? value : new Error(String(value));\n}\n\nfunction closeDatabase(): Error | undefined {\n  if (timer) clearInterval(timer);\n  timer = undefined;\n  try {\n    database?.close();\n    database = undefined;\n    return undefined;\n  } catch (err) {\n    return asError(err);\n  }\n}\n\nfunction addFailure(primary: Error, secondary: Error | undefined, message: string): Error {\n  return secondary ? new AggregateError([primary, secondary], message) : primary;\n}\n\nfunction fail(err: unknown): void {\n  if (stopping) return;\n  stopping = true;\n  let failure = asError(err);\n  try {\n    database?.release(data.token);\n  } catch (releaseError) {\n    failure = addFailure(failure, asError(releaseError), 'watch heartbeat and claim release both failed');\n  }\n  const closeError = closeDatabase();\n  failure = addFailure(failure, closeError, 'watch heartbeat and database cleanup both failed');\n  try {\n    send({ type: 'failure', error: serializeError(failure) });\n  } finally {\n    port.close();\n  }\n}\n\nasync function stop(): Promise<void> {\n  if (stopping) return;\n  stopping = true;\n  if (timer) clearInterval(timer);\n  let failure: Error | undefined;\n  try {\n    await renewing;\n    if (!database?.release(data.token)) throw new SenseError('WATCH_ACTIVE', 'watch ownership was replaced by another watcher');\n  } catch (err) {\n    failure = asError(err);\n  } finally {\n    const closeError = closeDatabase();\n    if (closeError) failure = failure ? addFailure(failure, closeError, 'watch heartbeat shutdown and database cleanup both failed') : closeError;\n    try {\n      if (failure) send({ type: 'failure', error: serializeError(failure) });\n      else send({ type: 'stopped' });\n    } finally {\n      port.close();\n    }\n  }\n}\n\nasync function main(): Promise<void> {\n  try {\n    database = new WatchClaimDatabase(data.configDir);\n    await database.acquire(data.token, data.pid, data.force);\n    send({ type: 'acquired' });\n    timer = setInterval(() => {\n      if (stopping) return;\n      renewing = renewing.then(() => {\n        if (!database?.renew(data.token)) throw new SenseError('WATCH_ACTIVE', 'watch ownership was replaced by another watcher');\n      });\n      renewing.catch(fail);\n    }, data.heartbeatIntervalMs);\n    port.on('message', (message: { type?: string }) => {\n      if (message.type === 'stop') void stop();\n    });\n  } catch (err) {\n    fail(err);\n  }\n}\n\nvoid main();\n"],"names":["parentPort","workerData","SenseError","serializeError","WatchClaimDatabase","requireParentPort","port","Error","data","database","timer","stopping","renewing","Promise","resolve","send","message","postMessage","asError","value","String","closeDatabase","clearInterval","undefined","close","err","addFailure","primary","secondary","AggregateError","fail","failure","release","token","releaseError","closeError","type","error","stop","main","configDir","acquire","pid","force","setInterval","then","renew","catch","heartbeatIntervalMs","on"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sensemaking",
-  "version": "0.24.3",
+  "version": "0.24.5",
   "description": "Query and search your markdown notes with context-aware progressive disclosure: SQL over frontmatter, links, and text, plus semantic search and link-graph ranking. No server, no build step.",
   "keywords": [
     "markdown",
@@ -93,7 +93,7 @@
     "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@duckdb/node-api": "*",
+    "@duckdb/node-api": "1.5.5-r.4",
     "@tursodatabase/database": "*",
     "@types/markdown-it-footnote": "^3.0.4",
     "@types/mocha": "*",