@mulmoclaude/core 0.27.0 → 0.29.0

package/dist/collection-watchers/index.js

@@ -1,12 +1,10 @@
 import { p as fieldText } from "../ids-D1M1T6KJ.js";
-import { S as itemIsDone, j as whenMatches } from "../promptSafety-RE1SPxBN.js";
+import { S as itemIsDone, j as whenMatches } from "../promptSafety-cZIeiZtB.js";
 import "../collection/index.js";
-import { W as itemFilePath, n as discoverCollections, r as loadCollection, tt as publishCollectionChange, u as storeFor } from "../discovery-B9Vfojyy.js";
-import { d as isTriggerDue, f as maybeSpawnSuccessor } from "../server-sGNe-msA.js";
+import { K as itemFilePath, n as discoverCollections, r as loadCollection, rt as publishCollectionChange, u as storeFor } from "../discovery-BbsJwVEq.js";
+import { d as isTriggerDue, f as maybeSpawnSuccessor } from "../server-DlG6ydHO.js";
 import { d as publish, m as updateForPlugin, n as clear, s as listAll } from "../notifier-ChpY0XrY.js";
-import path from "node:path";
-import { watch } from "node:fs";
-import { access, mkdir } from "node:fs/promises";
+import { access } from "node:fs/promises";
 //#region src/collection-watchers/config.ts
 var NOOP_LOG = {
 	info: () => {},
@@ -299,6 +297,15 @@ var watchers = /* @__PURE__ */ new Map();
 var rediscoveryTimer = null;
 var triggerTimer = null;
 var started = false;
+/** Guards the clock tick against overlapping itself. Paired with
+*  `watcherEpoch`: a teardown while a pass is in flight bumps the epoch, so
+*  that pass's `finally` knows it belongs to a dead generation and must not
+*  clear a guard the restarted watcher set now owns. `triggerTickInFlight`
+*  is what teardown AWAITS — clearing the flag alone would let a restart run
+*  a second pass alongside the first. */
+var triggerTickRunning = false;
+var watcherEpoch = 0;
+var triggerTickInFlight = null;
 /** Discovery options threaded into every `discoverCollections` /
 *  `loadCollection` / `sweepStaleActiveEntries` call. Production: empty
 *  (live workspace). Tests: `{ workspaceRoot, userSkillsDir }` pointing
@@ -306,15 +313,10 @@ var started = false;
 *  without threading through every signature. */
 var discoveryOpts = {};
 var itemSlots = /* @__PURE__ */ new Map();
-/** Per-slug single-flight for a storage (db-file) collection's full
-*  reconcile pass — a burst of db writes collapses to one pass + one
-*  trailing re-run, mirroring the per-item slots of the file watcher. */
-var storageSlots = /* @__PURE__ */ new Map();
-/** Trailing debounce per dataSource collection: an atomic file replace
-*  (Excel save, editor rename) surfaces as 2-3 fs events — collapse them
-*  into one change publish so live views refetch once. */
-var DATA_SOURCE_DEBOUNCE_MS = 300;
-var dataSourceTimers = /* @__PURE__ */ new Map();
+/** Per-slug single-flight for a COLLECTION-granularity reconcile — a burst
+*  of changes the store couldn't attribute to a record collapses into one
+*  pass plus one trailing re-run, mirroring the per-item slots. */
+var collectionSlots = /* @__PURE__ */ new Map();
 /** Boot entry point: sweep stale active entries, then mount watchers for
 *  every discovered collection and arm the periodic re-discovery poll.
 *  Idempotent — a second call is a no-op. */
@@ -336,8 +338,15 @@ async function startCollectionWatchers(opts = {}) {
 		const triggerMs = opts.triggerTickIntervalMs === void 0 ? TRIGGER_TICK_INTERVAL_MS : opts.triggerTickIntervalMs;
 		if (triggerMs !== null) {
 			triggerTimer = setInterval(() => {
-				tickTimeTriggers().catch((err) => {
+				if (triggerTickRunning) return;
+				triggerTickRunning = true;
+				const epoch = watcherEpoch;
+				triggerTickInFlight = tickTimeTriggers().catch((err) => {
 					log().warn("watcher trigger tick failed", { error: errMsg(err) });
+				}).finally(() => {
+					if (epoch !== watcherEpoch) return;
+					triggerTickRunning = false;
+					triggerTickInFlight = null;
 				});
 			}, triggerMs);
 			triggerTimer.unref();
@@ -360,20 +369,22 @@ async function stopCollectionWatchers() {
 		clearInterval(triggerTimer);
 		triggerTimer = null;
 	}
+	await triggerTickInFlight;
+	triggerTickInFlight = null;
+	watcherEpoch += 1;
+	triggerTickRunning = false;
 	for (const watcher of watchers.values()) try {
-		watcher.watcher.close();
+		watcher.unsubscribe();
 	} catch {}
 	watchers.clear();
 	itemSlots.clear();
-	storageSlots.clear();
-	for (const timer of dataSourceTimers.values()) clearTimeout(timer);
-	dataSourceTimers.clear();
+	collectionSlots.clear();
 	discoveryOpts = {};
 	started = false;
 }
 /** Test-only: manually trigger one rediscovery + reconcile pass. */
 async function _syncWatchersForTesting() {
-	await syncWatchers();
+	return syncWatchers();
 }
 /** Test-only: drive one wall-clock tick synchronously, with an optional
 *  injected clock. */
@@ -397,7 +408,6 @@ async function tickTimeTriggers(now = evalNow()) {
 			});
 			continue;
 		}
-		if (schema.dataSource !== void 0) continue;
 		if (!schema.triggerField && !schema.spawn) continue;
 		await reconcileAllItems(entry.collection, discoveryOpts, now);
 	}
@@ -413,12 +423,14 @@ async function syncWatchers() {
 		collections = await discoverCollections(discoveryOpts);
 	} catch (err) {
 		log().warn("watcher discover failed", { error: errMsg(err) });
-		return;
+		return false;
 	}
 	const vanishedMutated = stopVanishedWatchers(new Set(collections.map((collection) => collection.slug)));
 	const schemaMutated = await reconcileChangedSchemas(collections);
 	const addedMutated = await startNewWatchers(collections);
-	if (vanishedMutated || schemaMutated || addedMutated) await sweepStaleActiveEntries(discoveryOpts);
+	if (!vanishedMutated && !schemaMutated && !addedMutated) return false;
+	await sweepStaleActiveEntries(discoveryOpts);
+	return true;
 }
 function stopVanishedWatchers(liveSlugs) {
 	let mutated = false;
@@ -426,7 +438,7 @@ function stopVanishedWatchers(liveSlugs) {
 		if (liveSlugs.has(slug)) continue;
 		const watcher = watchers.get(slug);
 		if (watcher) try {
-			watcher.watcher.close();
+			watcher.unsubscribe();
 		} catch {}
 		watchers.delete(slug);
 		mutated = true;
@@ -459,7 +471,7 @@ async function reconcileChangedSchemas(collections) {
 		if (storagePathChanged(existing.schemaJson, collection.schema)) {
 			log().info("watcher storage path changed, remounting", { slug: collection.slug });
 			try {
-				existing.watcher.close();
+				existing.unsubscribe();
 			} catch {}
 			watchers.delete(collection.slug);
 			if (collection.schema.dataSource !== void 0) publishCollectionChange({
@@ -471,199 +483,119 @@ async function reconcileChangedSchemas(collections) {
 		}
 		existing.schemaJson = nextJson;
 		existing.collection = collection;
-		if (collection.schema.dataSource !== void 0) {
-			log().info("dataSource watcher schema changed, publishing", { slug: collection.slug });
-			publishCollectionChange({
-				slug: collection.slug,
-				op: "upsert"
-			});
-			mutated = true;
-			continue;
-		}
 		log().info("watcher schema changed, re-reconciling", { slug: collection.slug });
 		await reconcileAllItems(collection, discoveryOpts);
+		if (collection.schema.dataSource !== void 0) publishCollectionChange({
+			slug: collection.slug,
+			op: "upsert"
+		});
 		mutated = true;
 	}
 	return mutated;
 }
+/** Mount a watcher for every collection that doesn't have one yet. Returns
+*  whether the watcher SET actually changed — the starters report whether
+*  they mounted, because ATTEMPTING is not mounting. A start that throws
+*  (logged and swallowed inside the starter) leaves `watchers` untouched, so
+*  the collection is retried next tick; counting that as a mutation made
+*  `syncWatchers` sweep on every tick for as long as the failure persisted. */
 async function startNewWatchers(collections) {
 	let mutated = false;
 	for (const collection of collections) {
 		if (watchers.has(collection.slug)) continue;
-		if (collection.schema.dataSource !== void 0) await startDataSourceWatcher(collection);
-		else if (collection.schema.storage !== void 0) await startStorageWatcher(collection);
-		else await startWatcherFor(collection);
-		mutated = true;
+		if (await startWatcherFor(collection)) mutated = true;
 	}
 	return mutated;
 }
-/** Publish one (debounced) change event for a dataSource collection —
-*  live views refetch the whole collection; no per-row diffing. */
-function scheduleDataSourcePublish(slug) {
-	const existing = dataSourceTimers.get(slug);
-	if (existing) clearTimeout(existing);
-	const timer = setTimeout(() => {
-		dataSourceTimers.delete(slug);
-		publishCollectionChange({
-			slug,
-			op: "upsert"
-		});
-	}, DATA_SOURCE_DEBOUNCE_MS);
-	timer.unref?.();
-	dataSourceTimers.set(slug, timer);
-}
-/** Watch a dataSource collection's external data file. The watch mounts
-*  on the PARENT directory (watching the file itself goes stale after an
-*  atomic replace — the inode changes) and filters events to the file's
-*  basename; a null filename (platform quirk) is treated as a hit. No
-*  reconciler involvement — replacing the CSV just refreshes the views. */
-async function startDataSourceWatcher(collection) {
-	const file = collection.dataSourceFile;
-	if (file === void 0) return;
-	const dir = path.dirname(file);
-	const base = path.basename(file);
-	try {
-		await mkdir(dir, { recursive: true });
-		const watcher = watch(dir, { persistent: false }, (_eventType, filename) => {
-			if (filename !== null && filename !== base) return;
-			scheduleDataSourcePublish(collection.slug);
-		});
-		watcher.on("error", (err) => {
-			log().warn("dataSource watcher error", {
-				slug: collection.slug,
-				error: errMsg(err)
-			});
-		});
-		watchers.set(collection.slug, {
-			slug: collection.slug,
-			dataDir: dir,
-			watcher,
-			schemaJson: JSON.stringify(collection.schema),
-			collection
-		});
-		log().info("dataSource watcher started", {
-			slug: collection.slug,
-			file
-		});
-	} catch (err) {
-		log().warn("dataSource watcher start failed", {
-			slug: collection.slug,
-			error: errMsg(err)
-		});
-	}
-}
-/** Watch a `storage` collection's database file. One db file holds every
-*  record, so an event can't name WHICH record changed — each (debounced)
-*  event runs a full `reconcileAllItems` pass (bells / spawn) plus a
-*  change publish so views refetch after EXTERNAL edits too (host writes
-*  already publish their own change events; the extra ping is debounced
-*  and idempotent). Mounts on the parent dir, same as the dataSource
-*  watcher, so an atomic replace can't strand the watch. */
-async function startStorageWatcher(collection) {
-	const file = collection.storageFile;
-	if (file === void 0) return;
-	const dir = path.dirname(file);
-	const base = path.basename(file);
+/** Mount one collection's change subscription, whatever its backend.
+*
+*  The store decides how to detect a change and at what granularity; this
+*  decides what to do about one. That split is the point: adding a backend
+*  means implementing `watch` on its store, not another branch here.
+*
+*  A store without `watch` cannot report external changes at all — it is
+*  still registered (so bells reconcile at boot and on the clock tick), just
+*  without live updates. */
+async function startWatcherFor(collection) {
+	const { slug } = collection;
 	try {
-		await mkdir(dir, { recursive: true });
 		await reconcileAllItems(collection, discoveryOpts);
-		const watcher = watch(dir, { persistent: false }, (_eventType, rawFilename) => {
-			const filename = rawFilename === null ? null : String(rawFilename);
-			if (filename !== null && !filename.startsWith(base)) return;
-			scheduleStorageReconcile(collection.slug).catch((err) => {
-				log().warn("storage watcher reconcile failed", {
-					slug: collection.slug,
+		const store = storeFor(collection, discoveryOpts);
+		const unsubscribe = store.watch ? await store.watch((change) => {
+			handleStoreChange(slug, change).catch((err) => {
+				log().warn("store change handling failed", {
+					slug,
 					error: errMsg(err)
 				});
 			});
-		});
-		watcher.on("error", (err) => {
-			log().warn("storage watcher error", {
-				slug: collection.slug,
-				error: errMsg(err)
-			});
-		});
-		watchers.set(collection.slug, {
-			slug: collection.slug,
-			dataDir: dir,
-			watcher,
+		}) : () => {};
+		if (unsubscribe === null) {
+			log().warn("collection watcher could not arm, retrying next sync", { slug });
+			return false;
+		}
+		watchers.set(slug, {
+			slug,
+			dataDir: collection.dataDir,
+			unsubscribe,
 			schemaJson: JSON.stringify(collection.schema),
 			collection
 		});
-		log().info("storage watcher started", {
-			slug: collection.slug,
-			file
+		log().info("collection watcher started", {
+			slug,
+			live: store.watch !== void 0
 		});
+		return true;
 	} catch (err) {
-		log().warn("storage watcher start failed", {
-			slug: collection.slug,
+		log().warn("collection watcher start failed", {
+			slug,
 			error: errMsg(err)
 		});
+		return false;
 	}
 }
-function scheduleStorageReconcile(slug) {
-	return runSingleFlight(storageSlots, slug, async () => {
+/** React to one reported change. Backend-agnostic by construction — it sees
+*  only the granularity the store reported.
+*
+*  `item`: reconcile just that record, then publish it. `collection`: the
+*  store couldn't say which record, so re-derive everything and pair it with
+*  a sweep — a record deleted remotely leaves a bell that a walk over the
+*  SURVIVING records can never clear. */
+async function handleStoreChange(slug, change) {
+	if (change.kind === "collection") {
+		await scheduleCollectionReconcile(slug);
+		return;
+	}
+	const current = watchers.get(slug)?.collection;
+	if (!current) return;
+	await scheduleItemReconcile(current, change.itemId);
+}
+/** Full re-derivation for a collection-granularity change, single-flighted
+*  per slug so a burst of writes collapses into one pass plus one trailing
+*  re-run. */
+function scheduleCollectionReconcile(slug) {
+	return runSingleFlight(collectionSlots, slug, async () => {
 		const collection = await loadCollection(slug, discoveryOpts);
 		if (!collection) return;
 		await reconcileAllItems(collection, discoveryOpts);
 		await sweepStaleActiveEntries(discoveryOpts);
-		publishCollectionChange({
+	}, () => {
+		safePublish({
 			slug,
 			op: "upsert"
 		});
+		return Promise.resolve();
 	});
 }
-/** Test-only: drive one storage-collection reconcile pass directly. */
-function _scheduleStorageReconcileForTesting(slug) {
-	return scheduleStorageReconcile(slug);
+/** Test-only: feed one store-reported change through the same path a live
+*  subscription uses, so a test can pin how a change is reacted to without
+*  depending on fs.watch timing. */
+function _handleStoreChangeForTesting(slug, change) {
+	return handleStoreChange(slug, change);
 }
-async function startWatcherFor(collection) {
-	const { slug, schema, dataDir } = collection;
-	try {
-		await mkdir(dataDir, { recursive: true });
-		await reconcileAllItems(collection, discoveryOpts);
-		const watcher = watch(dataDir, { persistent: false }, (_eventType, filename) => {
-			onEvent(slug, filename).catch((err) => {
-				log().warn("watcher event failed", {
-					slug,
-					filename,
-					error: errMsg(err)
-				});
-			});
-		});
-		watcher.on("error", (err) => {
-			log().warn("watcher error", {
-				slug,
-				error: errMsg(err)
-			});
-		});
-		watchers.set(slug, {
-			slug,
-			dataDir,
-			watcher,
-			schemaJson: JSON.stringify(schema),
-			collection
-		});
-		log().info("watcher started", {
-			slug,
-			dataDir
-		});
-	} catch (err) {
-		log().warn("watcher start failed", {
-			slug,
-			error: errMsg(err)
-		});
-	}
+/** Test-only: drive one collection-granularity reconcile directly. */
+function _scheduleCollectionReconcileForTesting(slug) {
+	return scheduleCollectionReconcile(slug);
 }
-/** Test-only: the per-key single-flight scheduler. Exported so test code
-*  can drive rapid-fire calls directly and observe the trailing coalesce
-*  — `fs.watch` event timing is too flaky to assert against.
-*
-*  Single-flight semantics: while a reconcile is in flight for a given
-*  (slug, itemId), additional events on the same key set `pending = true`
-*  and return — the running reconcile re-runs once after it completes.
-*  This collapses fs.watch's rapid-fire bursts (atomic rename surfaces as
-*  2-3 events) into a single reconcile + one trailing re-run. */
 function _scheduleItemReconcileForTesting(collection, itemId) {
 	return scheduleItemReconcile(collection, itemId);
 }
@@ -737,27 +669,7 @@ function safePublish(payload) {
 		});
 	}
 }
-/** Handle a single fs.watch event. Re-loads the collection (schema may
-*  have changed since startup), filters out non-record files, and
-*  forwards to the single-flighted reconciler. `filename === null` (rare,
-*  platform-specific) triggers a full directory rescan to be safe. */
-async function onEvent(slug, filename) {
-	const collection = await loadCollection(slug, discoveryOpts);
-	if (!collection) return;
-	if (filename === null) {
-		try {
-			await reconcileAllItems(collection, discoveryOpts);
-			await sweepStaleActiveEntries(discoveryOpts);
-		} finally {
-			safePublish({ slug });
-		}
-		return;
-	}
-	const name = typeof filename === "string" ? filename : filename.toString("utf-8");
-	if (!name.endsWith(".json") || name.startsWith(".")) return;
-	await scheduleItemReconcile(collection, name.slice(0, -5));
-}
 //#endregion
-export { _resetReconcilerLocksForTesting, _scheduleItemReconcileForTesting, _scheduleStorageReconcileForTesting, _syncWatchersForTesting, _tickTimeTriggersForTesting, clearItemNotification, configureCollectionWatchers, evalNow, itemIsDone, reconcileAllItems, reconcileItem, resetCollectionWatchersConfig, resolveDisplayLabel, startCollectionWatchers, stopCollectionWatchers, sweepStaleActiveEntries };
+export { _handleStoreChangeForTesting, _resetReconcilerLocksForTesting, _scheduleCollectionReconcileForTesting, _scheduleItemReconcileForTesting, _syncWatchersForTesting, _tickTimeTriggersForTesting, clearItemNotification, configureCollectionWatchers, evalNow, itemIsDone, reconcileAllItems, reconcileItem, resetCollectionWatchersConfig, resolveDisplayLabel, startCollectionWatchers, stopCollectionWatchers, sweepStaleActiveEntries };
 
 //# sourceMappingURL=index.js.map