@mulmoclaude/core 0.27.0 → 0.29.0

package/dist/collection-watchers/index.cjs

@@ -1,14 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_rolldown_runtime = require("../rolldown-runtime-D6vf50IK.cjs");
 const require_ids = require("../ids-DWmHjm17.cjs");
-const require_promptSafety = require("../promptSafety-0ZKHX-6J.cjs");
+const require_promptSafety = require("../promptSafety-BFt2g_wn.cjs");
 require("../collection/index.cjs");
-const require_discovery = require("../discovery-BxbJy2VN.cjs");
-const require_server = require("../server-DOGKfUuD.cjs");
+const require_discovery = require("../discovery-Bklck7Ck.cjs");
+const require_server = require("../server-CghbYZFY.cjs");
 const require_notifier = require("../notifier-bS8IEeLA.cjs");
-let node_path = require("node:path");
-node_path = require_rolldown_runtime.__toESM(node_path, 1);
-let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 //#region src/collection-watchers/config.ts
 var NOOP_LOG = {
@@ -302,6 +298,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
@@ -309,15 +314,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. */
@@ -339,8 +339,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();
@@ -363,20 +370,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. */
@@ -400,7 +409,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);
 	}
@@ -416,12 +424,14 @@ async function syncWatchers() {
 		collections = await require_discovery.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;
@@ -429,7 +439,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;
@@ -462,7 +472,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) require_discovery.publishCollectionChange({
@@ -474,199 +484,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 });
-			require_discovery.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) require_discovery.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);
-		require_discovery.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 = node_path.default.dirname(file);
-	const base = node_path.default.basename(file);
-	try {
-		await (0, node_fs_promises.mkdir)(dir, { recursive: true });
-		const watcher = (0, node_fs.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 = node_path.default.dirname(file);
-	const base = node_path.default.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 (0, node_fs_promises.mkdir)(dir, { recursive: true });
 		await reconcileAllItems(collection, discoveryOpts);
-		const watcher = (0, node_fs.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 = require_discovery.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 require_discovery.loadCollection(slug, discoveryOpts);
 		if (!collection) return;
 		await reconcileAllItems(collection, discoveryOpts);
 		await sweepStaleActiveEntries(discoveryOpts);
-		require_discovery.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 (0, node_fs_promises.mkdir)(dataDir, { recursive: true });
-		await reconcileAllItems(collection, discoveryOpts);
-		const watcher = (0, node_fs.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);
 }
@@ -740,30 +670,11 @@ 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 require_discovery.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
+exports._handleStoreChangeForTesting = _handleStoreChangeForTesting;
 exports._resetReconcilerLocksForTesting = _resetReconcilerLocksForTesting;
+exports._scheduleCollectionReconcileForTesting = _scheduleCollectionReconcileForTesting;
 exports._scheduleItemReconcileForTesting = _scheduleItemReconcileForTesting;
-exports._scheduleStorageReconcileForTesting = _scheduleStorageReconcileForTesting;
 exports._syncWatchersForTesting = _syncWatchersForTesting;
 exports._tickTimeTriggersForTesting = _tickTimeTriggersForTesting;
 exports.clearItemNotification = clearItemNotification;