@mulmoclaude/core 3.7.0 → 3.11.0

package/dist/collection-watchers/index.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_root = require("../root-rPH6FGDT.cjs");
-const require_calendarGrid = require("../calendarGrid-DGILaVxI.cjs");
-const require_promptSafety = require("../promptSafety-NNGViiCr.cjs");
+const require_itemId = require("../itemId-Dzrr3vs5.cjs");
+const require_promptSafety = require("../promptSafety-CWqYq-NS.cjs");
 require("../collection/index.cjs");
-const require_store = require("../store-5_P_NsGa.cjs");
-const require_server = require("../server-CWZyg8fn.cjs");
+const require_discovery = require("../discovery-BsXiDZBR.cjs");
+const require_server = require("../server-X_magqUa.cjs");
 const require_notifier = require("../notifier-DZJj0sOh.cjs");
 let node_fs_promises = require("node:fs/promises");
 //#region src/collection-watchers/config.ts
@@ -86,8 +86,8 @@ var SHARED_MARK = "#";
 *  Deliberately NOT on the package barrel: the id is a disk format, not an API. */
 function completionLegacyId(slug, itemId, root, aid) {
 	if (root !== void 0 && aid !== void 0) throw new Error(`completionLegacyId: "${slug}" carries both a root (${root}) and an app (${aid})`);
-	if (!require_calendarGrid.isValidCollectionName(slug)) throw new Error(`completionLegacyId: collection name "${slug}" is not a valid collection name`);
-	if (aid !== void 0 && !require_calendarGrid.isValidCollectionName(aid)) throw new Error(`completionLegacyId: app id "${aid}" is not a valid collection name`);
+	if (!require_itemId.isValidCollectionName(slug)) throw new Error(`completionLegacyId: collection name "${slug}" is not a valid collection name`);
+	if (aid !== void 0 && !require_itemId.isValidCollectionName(aid)) throw new Error(`completionLegacyId: app id "${aid}" is not a valid collection name`);
 	return `${LEGACY_ID_PREFIX}${aid !== void 0 ? `${SHARED_MARK}${aid}${ROOT_SEP}` : root === void 0 ? "" : `${ROOT_MARK}${require_root.canonicalRoot(root)}${ROOT_SEP}`}${slug}:${itemId}`;
 }
 /** Decode a key back into its (root, slug, itemId), or null if the string
@@ -130,7 +130,7 @@ function parseCompletionLegacyId(legacyId) {
 function resolveDisplayLabel(schema, item, itemId) {
 	const { displayField } = schema;
 	if (!displayField) return itemId;
-	const label = require_calendarGrid.fieldText(item[displayField]).trim();
+	const label = require_itemId.fieldText(item[displayField]).trim();
 	return label.length > 0 ? label : itemId;
 }
 /** The scope a collection's bells belong to.
@@ -285,7 +285,7 @@ async function reconcileItem(collection, itemId, ioOpts = {}, now = evalNow()) {
 		await clearScoped(slug, itemId, scope);
 		return;
 	}
-	const item = await require_store.storeFor(collection, ioOpts).read(itemId);
+	const item = await require_discovery.storeFor(collection, ioOpts).read(itemId);
 	if (item === null) {
 		await clearScoped(slug, itemId, scope);
 		return;
@@ -324,7 +324,7 @@ async function reconcileAllItems(collection, ioOpts = {}, now = evalNow()) {
 	if (!schema.completionField) return;
 	let items;
 	try {
-		items = await require_store.storeFor(collection, ioOpts).list();
+		items = await require_discovery.storeFor(collection, ioOpts).list();
 	} catch (err) {
 		log().warn("reconcile list failed", {
 			slug,
@@ -369,7 +369,7 @@ function sweepVerdict(entry, ownRoot) {
 *  whose record the forward pass can never walk to (a delete leaves a bell that
 *  a walk over the SURVIVING records cannot clear). */
 async function isStaleEntry(slug, itemId, opts, aid) {
-	const collection = await require_store.loadCollection(slug, opts);
+	const collection = await require_discovery.loadCollection(slug, opts);
 	if (aid !== void 0 && collection?.appId !== aid) return false;
 	if (!collection || !collection.schema.completionField) return true;
 	return recordNoLongerBells(collection, itemId, opts);
@@ -378,7 +378,7 @@ async function isStaleEntry(slug, itemId, opts, aid) {
 *  `notifyWhen`. Split out so the caller stays one decision — WHOSE entry this
 *  is — and this one stays the other. */
 async function recordNoLongerBells(collection, itemId, opts) {
-	const item = await require_store.storeFor(collection, opts).read(itemId);
+	const item = await require_discovery.storeFor(collection, opts).read(itemId);
 	return item === null || require_promptSafety.itemIsDone(collection.schema, item) || !require_promptSafety.whenMatches(collection.schema.notifyWhen, item);
 }
 /** One entry's fate: whose it is (`sweepVerdict`), then — when it is this
@@ -451,7 +451,7 @@ var WATCHER_ROOT_CONFLICT = "WATCHER_ROOT_CONFLICT";
 *  is a comparison, and under an explicit-root binding there is no default to
 *  read, which is not an error here. */
 function effectiveRoot(opts) {
-	const root = opts?.workspaceRoot ?? require_store.peekWorkspaceRoot() ?? void 0;
+	const root = opts?.workspaceRoot ?? require_discovery.peekWorkspaceRoot() ?? void 0;
 	return root === void 0 ? void 0 : require_root.canonicalRoot(root);
 }
 /** The discovery options a generation runs under, with an explicit root put in
@@ -639,7 +639,7 @@ async function tickTimeTriggers(gen, now = evalNow()) {
 *  shared collection's store grows an `onSnapshot` watch, it stops being
 *  special here with no edit to this file. */
 function cannotReportChanges(gen, collection) {
-	return require_store.storeFor(collection, gen.discoveryOpts).watch === void 0;
+	return require_discovery.storeFor(collection, gen.discoveryOpts).watch === void 0;
 }
 /** True when a schema declares behaviour that only a reconcile pass can
 *  produce: bells (`completionField`), date-triggered bells (`triggerField`),
@@ -674,7 +674,7 @@ async function reconcileUnwatched(gen, collection, now) {
 *  already sweeps on a changed schema and on a vanished slug, and the sweep is
 *  what clears bells the declaration no longer justifies. */
 async function tickUnwatchedCollections(gen, now) {
-	if (require_store.firestoreHandle() === null) return;
+	if (require_discovery.firestoreHandle() === null) return;
 	const pending = [...gen.watchers.values()].map((entry) => entry.collection).filter((collection) => cannotReportChanges(gen, collection) && needsReconcilePass(collection.schema));
 	if (pending.length === 0) return;
 	for (const collection of pending) await reconcileUnwatched(gen, collection, now);
@@ -688,7 +688,7 @@ async function tickUnwatchedCollections(gen, now) {
 async function syncWatchers(gen) {
 	let collections;
 	try {
-		collections = await require_store.discoverCollections(gen.discoveryOpts);
+		collections = await require_discovery.discoverCollections(gen.discoveryOpts);
 	} catch (err) {
 		log().warn("watcher discover failed", { error: errMsg(err) });
 		return false;
@@ -714,10 +714,22 @@ function stopVanishedWatchers(gen, liveSlugs) {
 	}
 	return mutated;
 }
+/** True when the collection's records moved — a different `dataSource.path`, a
+*  different `dataPath`, a flip between the two modes, or a different APP. The
+*  mount (an fs.watch, or a Firestore listener) is bound to the OLD location,
+*  so it must be remounted, not just re-reconciled.
+*
+*  `appId` belongs here even though it is not in the schema: it is resolved
+*  separately, from the repository's `app.json`. Point that file at another app
+*  and every read and write follows immediately, while a listener armed on the
+*  old one keeps running — so the collection would serve the NEW app's records
+*  and be woken by the OLD app's changes, forever. */
+function backendMoved(previous, next) {
+	return previous.appId !== next.appId || storagePathChanged(previous.schema, next.schema);
+}
 /** True when a schema edit moved the collection's storage — a different
 *  `dataSource.path`, a different `dataPath`, or a flip between the two
-*  modes. The mounted fs.watch is bound to the OLD location, so it must
-*  be remounted, not just re-reconciled. */
+*  modes. */
 function storagePathChanged(previous, next) {
 	return previous.dataSource?.path !== next.dataSource?.path || previous.dataPath !== next.dataPath || previous.storage?.type !== next.storage?.type || storageFilePath(previous.storage) !== storageFilePath(next.storage);
 }
@@ -729,23 +741,30 @@ function storageFilePath(storage) {
 }
 /** Re-reconcile already-watched collections whose schema changed since
 *  the last tick. New collections fall through to `startNewWatchers`. */
+/** Unmount a collection whose records moved. `startNewWatchers` (right after
+*  this pass in syncWatchers) remounts it on the new location. A dataSource
+*  collection also gets a change ping so open views refetch immediately. */
+function dropStaleMount(gen, existing, collection) {
+	log().info("watcher backend moved, remounting", { slug: collection.slug });
+	try {
+		existing.unsubscribe();
+	} catch {}
+	gen.watchers.delete(collection.slug);
+	if (collection.schema.dataSource !== void 0) safePublish(gen, collection, {
+		slug: collection.slug,
+		op: "upsert"
+	});
+}
 async function reconcileChangedSchemas(gen, collections) {
 	let mutated = false;
 	for (const collection of collections) {
 		const existing = gen.watchers.get(collection.slug);
 		if (!existing) continue;
 		const nextJson = JSON.stringify(collection.schema);
-		if (existing.schemaJson === nextJson) continue;
-		if (storagePathChanged(existing.collection.schema, collection.schema)) {
-			log().info("watcher storage path changed, remounting", { slug: collection.slug });
-			try {
-				existing.unsubscribe();
-			} catch {}
-			gen.watchers.delete(collection.slug);
-			if (collection.schema.dataSource !== void 0) safePublish(gen, {
-				slug: collection.slug,
-				op: "upsert"
-			});
+		const moved = backendMoved(existing.collection, collection);
+		if (existing.schemaJson === nextJson && !moved) continue;
+		if (moved) {
+			dropStaleMount(gen, existing, collection);
 			mutated = true;
 			continue;
 		}
@@ -753,7 +772,7 @@ async function reconcileChangedSchemas(gen, collections) {
 		existing.collection = collection;
 		log().info("watcher schema changed, re-reconciling", { slug: collection.slug });
 		await reconcileAllItems(collection, gen.discoveryOpts);
-		if (collection.schema.dataSource !== void 0) safePublish(gen, {
+		if (collection.schema.dataSource !== void 0) safePublish(gen, collection, {
 			slug: collection.slug,
 			op: "upsert"
 		});
@@ -788,7 +807,7 @@ async function startWatcherFor(gen, collection) {
 	const { slug } = collection;
 	try {
 		await reconcileAllItems(collection, gen.discoveryOpts);
-		const store = require_store.storeFor(collection, gen.discoveryOpts);
+		const store = require_discovery.storeFor(collection, gen.discoveryOpts);
 		const unsubscribe = store.watch ? await store.watch((change) => {
 			handleStoreChange(gen, slug, change).catch((err) => {
 				log().warn("store change handling failed", {
@@ -841,13 +860,15 @@ async function handleStoreChange(gen, slug, change) {
 *  per slug so a burst of writes collapses into one pass plus one trailing
 *  re-run. */
 function scheduleCollectionReconcile(gen, slug) {
+	let target = gen.watchers.get(slug)?.collection ?? { appId: void 0 };
 	return runSingleFlight(gen.collectionSlots, slug, async () => {
-		const collection = await require_store.loadCollection(slug, gen.discoveryOpts);
+		const collection = await require_discovery.loadCollection(slug, gen.discoveryOpts);
 		if (!collection) return;
+		target = collection;
 		await reconcileAllItems(collection, gen.discoveryOpts);
 		await sweepStaleActiveEntries(gen.discoveryOpts);
 	}, () => {
-		safePublish(gen, {
+		safePublish(gen, target, {
 			slug,
 			op: "upsert"
 		});
@@ -911,16 +932,32 @@ function runSingleFlight(slots, key, pass, onSettled) {
 *  file-backed collections reach here; a `storage` (db) collection has no
 *  per-record file and publishes wholesale in `scheduleStorageReconcile`. */
 async function publishItemChange(gen, collection, itemId) {
-	const changeOp = await itemFileExists(collection.dataDir, itemId) ? "upsert" : "delete";
-	safePublish(gen, {
+	const changeOp = await recordStillExists(gen, collection, itemId) ? "upsert" : "delete";
+	safePublish(gen, collection, {
 		slug: collection.slug,
 		ids: [itemId],
 		op: changeOp
 	});
 }
+/** Upsert or delete? Answered by whatever actually holds the record.
+*
+*  A shared collection's records are Firestore documents — there is no item
+*  file, so the file check answers "gone" for every one of them and each live
+*  change would be published as a DELETE. Asking the store is the question the
+*  file check was standing in for; the file path keeps it because it is
+*  cheaper and its semantics (an unreadable dir, an id that is not a safe
+*  filename) are already settled there. */
+async function recordStillExists(gen, collection, itemId) {
+	if (collection.appId === void 0) return itemFileExists(collection.dataDir, itemId);
+	try {
+		return await require_discovery.storeFor(collection, gen.discoveryOpts).read(itemId) !== null;
+	} catch {
+		return true;
+	}
+}
 async function itemFileExists(dataDir, itemId) {
 	try {
-		await (0, node_fs_promises.access)(require_store.itemFilePath(dataDir, itemId));
+		await (0, node_fs_promises.access)(require_discovery.itemFilePath(dataDir, itemId));
 		return true;
 	} catch {
 		return false;
@@ -934,10 +971,17 @@ async function itemFileExists(dataDir, itemId) {
 *  carries only absolute paths, and a root reconstructed by string surgery
 *  would be a guess. Undefined in a single-workspace host, which is exactly
 *  what the payload contract means by "the host's configured root". */
-function safePublish(gen, payload) {
-	const enriched = require_store.collectionChangePayload(payload, gen.discoveryOpts.workspaceRoot);
+/** Publish a change on the channel the collection actually lives on.
+*
+*  A SHARED collection is not keyed by this checkout: its identity is
+*  `(aid, cid)`, and the same collection is open in every clone. Publishing it
+*  as `(root, slug)` sends the refresh to a channel no shared subscriber is
+*  listening on — the live update simply never arrives, and nothing errors.
+*  That is why this takes the collection rather than a bare slug. */
+function safePublish(gen, collection, base) {
+	const enriched = collection.appId === void 0 ? require_discovery.collectionChangePayload(base, gen.discoveryOpts.workspaceRoot) : require_discovery.sharedCollectionChangePayload(base, collection.appId);
 	try {
-		require_store.publishCollectionChange(enriched);
+		require_discovery.publishCollectionChange(enriched);
 	} catch (err) {
 		log().warn("collection change publish failed", {
 			slug: enriched.slug,