@mulmoclaude/core 0.1.0 → 0.2.0

package/dist/collection-watchers/config.d.ts

@@ -0,0 +1,49 @@
+import { NotifierSeverity } from '../notifier';
+/** Two-level urgency a pending record can carry, derived from the
+ *  schema's `notifyWhen` spec. The host maps this onto its own severity
+ *  scale via `priorityToSeverity`. */
+export type CompletionPriority = "normal" | "high";
+export interface CollectionWatcherLogger {
+    info: (message: string, data?: Record<string, unknown>) => void;
+    warn: (message: string, data?: Record<string, unknown>) => void;
+}
+/** The host-specific notification surface the reconciler binds to. The
+ *  reconciler owns the internal `legacyId` key (it encodes slug+itemId
+ *  and round-trips it through `pluginData`); the adapter only wraps /
+ *  unwraps it into whatever shape the host's bell expects. */
+export interface CollectionNotificationAdapter {
+    /** Plugin namespace these bell entries publish under (MulmoClaude: "todo"). */
+    pluginPkg: string;
+    /** Map a record's completion priority onto the host's bell severity. */
+    priorityToSeverity: (priority: CompletionPriority) => NotifierSeverity;
+    /** Build the in-app deep-link the bell row routes to on click. */
+    buildNavigateTarget: (slug: string, itemId: string) => string;
+    /** Wrap the reconciler's internal key + priority into the host's
+     *  `pluginData` shape. Stored verbatim on the entry; recovered via
+     *  `readEntry`. */
+    buildPluginData: (input: {
+        legacyId: string;
+        slug: string;
+        itemId: string;
+        priority: CompletionPriority;
+        navigateTarget: string;
+    }) => unknown;
+    /** Recognise a bell entry produced by this reconciler and recover its
+     *  internal key + stored priority. Returns null for entries that didn't
+     *  originate here, so `listAll()` scans skip foreign entries. */
+    readEntry: (pluginData: unknown) => {
+        legacyId: string;
+        priority: CompletionPriority;
+    } | null;
+}
+/** Wire the host adapter + logger. Call once at startup, before
+ *  `startCollectionWatchers` or any direct reconcile call. */
+export declare function configureCollectionWatchers(config: {
+    adapter: CollectionNotificationAdapter;
+    log?: CollectionWatcherLogger;
+}): void;
+export declare function requireAdapter(): CollectionNotificationAdapter;
+export declare function log(): CollectionWatcherLogger;
+/** Test-only: clear the host wiring. */
+export declare function resetCollectionWatchersConfig(): void;
+export declare function errMsg(err: unknown): string;

package/dist/collection-watchers/index.cjs

@@ -0,0 +1,554 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../chunk-CKQMccvm.cjs");
+const require_collection_index = require("../collection/index.cjs");
+const require_server = require("../server-BjoKk2tR.cjs");
+const require_notifier = require("../notifier-lJ4v2Y6B.cjs");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+//#region src/collection-watchers/config.ts
+var NOOP_LOG = {
+	info: () => {},
+	warn: () => {}
+};
+var adapter = null;
+var activeLogger = NOOP_LOG;
+/** Wire the host adapter + logger. Call once at startup, before
+*  `startCollectionWatchers` or any direct reconcile call. */
+function configureCollectionWatchers(config) {
+	({adapter} = config);
+	activeLogger = config.log ?? NOOP_LOG;
+}
+function requireAdapter() {
+	if (!adapter) throw new Error("collection-watchers: configureCollectionWatchers() not called");
+	return adapter;
+}
+function log() {
+	return activeLogger;
+}
+/** Test-only: clear the host wiring. */
+function resetCollectionWatchersConfig() {
+	adapter = null;
+	activeLogger = NOOP_LOG;
+}
+function errMsg(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/collection-watchers/reconciler.ts
+/** The internal-id prefix every collection-completion bell entry carries.
+*  Used both to build new keys and to filter sweep candidates from the
+*  active bell. */
+var LEGACY_ID_PREFIX = "collection-completion:";
+/** Stable key encoding slug + item, round-tripped through the entry's
+*  `pluginData` so we can find it later without a side state file. Slug +
+*  itemId are upstream-validated via `safeSlugName`, which forbids the
+*  colon separator, so the two-segment parse below is unambiguous. */
+function completionLegacyId(slug, itemId) {
+	return `${LEGACY_ID_PREFIX}${slug}:${itemId}`;
+}
+/** Decode a key back into its (slug, itemId) pair, or null if the string
+*  didn't originate from this module. Used by the sweep step. */
+function parseCompletionLegacyId(legacyId) {
+	if (!legacyId.startsWith(LEGACY_ID_PREFIX)) return null;
+	const body = legacyId.slice(22);
+	const colon = body.indexOf(":");
+	if (colon < 0) return null;
+	return {
+		slug: body.slice(0, colon),
+		itemId: body.slice(colon + 1)
+	};
+}
+/** The human-readable label shown in a completion notification's title.
+*  Uses the schema's `displayField` value when declared and non-empty;
+*  otherwise falls back to the record's primaryKey (`itemId`). */
+function resolveDisplayLabel(schema, item, itemId) {
+	const { displayField } = schema;
+	if (!displayField) return itemId;
+	const raw = item[displayField];
+	if (raw === void 0 || raw === null) return itemId;
+	const label = String(raw).trim();
+	return label.length > 0 ? label : itemId;
+}
+/** True iff the schema declares completion tracking AND the item's
+*  `completionField` value (stringified) is in `completionDoneValues`. */
+function itemIsDone(schema, item) {
+	const { completionField, completionDoneValues } = schema;
+	if (!completionField || !completionDoneValues) return false;
+	const raw = item[completionField];
+	if (raw === void 0 || raw === null) return false;
+	return completionDoneValues.includes(String(raw));
+}
+/** Every active bell entry whose key matches this (slug, itemId).
+*  Returns multiple when defensive cleanup is needed. Scans `listAll()`
+*  — cheap because the active set is bounded. */
+async function findActiveEntries(slug, itemId) {
+	const adapter = requireAdapter();
+	const legacyId = completionLegacyId(slug, itemId);
+	return (await require_notifier.listAll()).filter((entry) => adapter.readEntry(entry.pluginData)?.legacyId === legacyId);
+}
+async function findActiveEntryIds(slug, itemId) {
+	return (await findActiveEntries(slug, itemId)).map((entry) => entry.id);
+}
+var ensureLocks = /* @__PURE__ */ new Map();
+/** Bell priority for a record: the FIRST flagged value in `notifyWhen.in`
+*  (most urgent) reads `high`, every other flagged value `normal`.
+*  Collections with no `notifyWhen` (notify for every open record) stay
+*  `normal`. */
+function notifyPriorityForItem(schema, item) {
+	const spec = schema.notifyWhen;
+	if (!spec) return "normal";
+	const value = item[spec.field] === void 0 || item[spec.field] === null ? "" : String(item[spec.field]);
+	return spec.in.indexOf(value) === 0 ? "high" : "normal";
+}
+async function ensureItemNotification(slug, schema, itemId, displayLabel, priority) {
+	const legacyId = completionLegacyId(slug, itemId);
+	while (true) {
+		const inflight = ensureLocks.get(legacyId);
+		if (!inflight) break;
+		await inflight.promise;
+	}
+	const lock = { promise: doEnsureItemNotification(slug, schema, itemId, legacyId, displayLabel, priority) };
+	ensureLocks.set(legacyId, lock);
+	try {
+		await lock.promise;
+	} finally {
+		if (ensureLocks.get(legacyId) === lock) ensureLocks.delete(legacyId);
+	}
+}
+/** Converge any already-present bell entries to `priority`, updating in
+*  place (preserving id / position / createdAt) so a record whose flagged
+*  value changed while it stayed pending re-colours the bell without a
+*  clear+republish flicker. No-op when the stored priority already matches. */
+async function reconcileEntrySeverity(slug, itemId, entries, priority) {
+	const adapter = requireAdapter();
+	for (const entry of entries) {
+		const parsed = adapter.readEntry(entry.pluginData);
+		if (!parsed || parsed.priority === priority) continue;
+		await require_notifier.updateForPlugin(adapter.pluginPkg, entry.id, {
+			severity: adapter.priorityToSeverity(priority),
+			pluginData: adapter.buildPluginData({
+				legacyId: parsed.legacyId,
+				slug,
+				itemId,
+				priority,
+				navigateTarget: adapter.buildNavigateTarget(slug, itemId)
+			})
+		});
+	}
+}
+async function doEnsureItemNotification(slug, schema, itemId, legacyId, displayLabel, priority) {
+	const adapter = requireAdapter();
+	try {
+		const existing = await findActiveEntries(slug, itemId);
+		if (existing.length > 0) {
+			await reconcileEntrySeverity(slug, itemId, existing, priority);
+			return;
+		}
+		const navigateTarget = adapter.buildNavigateTarget(slug, itemId);
+		await require_notifier.publish({
+			pluginPkg: adapter.pluginPkg,
+			severity: adapter.priorityToSeverity(priority),
+			lifecycle: "action",
+			title: `${schema.title}: ${displayLabel}`,
+			navigateTarget,
+			pluginData: adapter.buildPluginData({
+				legacyId,
+				slug,
+				itemId,
+				priority,
+				navigateTarget
+			})
+		});
+	} catch (err) {
+		log().warn("notify ensure failed", {
+			slug,
+			itemId,
+			error: errMsg(err)
+		});
+	}
+}
+/** Idempotently clear EVERY bell entry that matches this (slug, itemId).
+*  Silent no-op when nothing matches. The "every" is defensive: if a
+*  duplicate ever slips through, this drains the lot. */
+async function clearItemNotification(slug, itemId) {
+	try {
+		const ids = await findActiveEntryIds(slug, itemId);
+		for (const entryId of ids) await require_notifier.clear(entryId);
+	} catch (err) {
+		log().warn("notify clear failed", {
+			slug,
+			itemId,
+			error: errMsg(err)
+		});
+	}
+}
+/** Reconcile one item to the desired bell state. Re-reads the record from
+*  disk so the decision is grounded in current truth, not in the event
+*  payload. Safe to call when the file is missing (delete path).
+*
+*  `ioOpts` flows into `readItem`'s workspace-containment check —
+*  production callers (the watcher) pass nothing; tests pass
+*  `{ workspaceRoot: <tmpdir> }` so the check accepts a fixture dataDir. */
+async function reconcileItem(slug, schema, dataDir, itemId, ioOpts = {}, now = /* @__PURE__ */ new Date()) {
+	if (!schema.completionField) {
+		await clearItemNotification(slug, itemId);
+		return;
+	}
+	const item = await require_server.readItem(dataDir, itemId, ioOpts);
+	if (item === null) {
+		await clearItemNotification(slug, itemId);
+		return;
+	}
+	await require_server.maybeSpawnSuccessor(slug, schema, dataDir, item, itemId, ioOpts);
+	if (itemIsDone(schema, item)) {
+		await clearItemNotification(slug, itemId);
+		return;
+	}
+	if (schema.triggerField) {
+		const triggerRaw = item[schema.triggerField];
+		const due = require_server.isTriggerDue(triggerRaw, now, schema.triggerLeadDays);
+		if (due === null && !(triggerRaw === void 0 || triggerRaw === null || triggerRaw === "")) log().warn("trigger date unparseable, suppressing bell", {
+			slug,
+			itemId,
+			triggerField: schema.triggerField
+		});
+		if (due !== true) {
+			await clearItemNotification(slug, itemId);
+			return;
+		}
+	}
+	if (!require_collection_index.whenMatches(schema.notifyWhen, item)) {
+		await clearItemNotification(slug, itemId);
+		return;
+	}
+	await ensureItemNotification(slug, schema, itemId, resolveDisplayLabel(schema, item, itemId), notifyPriorityForItem(schema, item));
+}
+/** Boot-time reconcile: walk every record under `dataDir` once and
+*  reconcile it. Catches up changes that happened while the server was
+*  down. Deleted items are covered by `sweepStaleActiveEntries`, not this
+*  function (it only sees files that exist). */
+async function reconcileAllItems(slug, schema, dataDir, ioOpts = {}, now = /* @__PURE__ */ new Date()) {
+	if (!schema.completionField) return;
+	let items;
+	try {
+		items = await require_server.listItems(dataDir, ioOpts);
+	} catch (err) {
+		log().warn("reconcile list failed", {
+			slug,
+			dataDir,
+			error: errMsg(err)
+		});
+		return;
+	}
+	const { primaryKey } = schema;
+	for (const item of items) {
+		const raw = item[primaryKey];
+		if (typeof raw !== "string" || raw.length === 0) continue;
+		await reconcileItem(slug, schema, dataDir, raw, ioOpts, now);
+	}
+}
+/** Boot-time sweep over the active bell: drop any entries whose underlying
+*  file is gone, whose collection was deleted, whose schema no longer
+*  tracks completion, or whose item is now done. Reverse-covers the cases
+*  `reconcileAllItems` misses (it only walks files that exist). */
+async function sweepStaleActiveEntries(opts = {}) {
+	const adapter = requireAdapter();
+	let entries;
+	try {
+		entries = await require_notifier.listAll();
+	} catch (err) {
+		log().warn("sweep list failed", { error: errMsg(err) });
+		return;
+	}
+	for (const entry of entries) {
+		const own = adapter.readEntry(entry.pluginData);
+		if (!own) continue;
+		const parsed = parseCompletionLegacyId(own.legacyId);
+		if (!parsed) continue;
+		const { slug, itemId } = parsed;
+		try {
+			const collection = await require_server.loadCollection(slug, opts);
+			if (!collection || !collection.schema.completionField) {
+				await require_notifier.clear(entry.id);
+				continue;
+			}
+			const item = await require_server.readItem(collection.dataDir, itemId, opts);
+			if (item === null || itemIsDone(collection.schema, item) || !require_collection_index.whenMatches(collection.schema.notifyWhen, item)) await require_notifier.clear(entry.id);
+		} catch (err) {
+			log().warn("sweep entry failed", {
+				slug,
+				itemId,
+				error: errMsg(err)
+			});
+		}
+	}
+}
+/** Test-only: clear the per-key in-flight locks. */
+function _resetReconcilerLocksForTesting() {
+	ensureLocks.clear();
+}
+//#endregion
+//#region src/collection-watchers/watcher.ts
+var ONE_SECOND_MS = 1e3;
+var ONE_MINUTE_MS = 60 * ONE_SECOND_MS;
+var REDISCOVERY_INTERVAL_MS = 30 * ONE_SECOND_MS;
+var TRIGGER_TICK_INTERVAL_MS = ONE_MINUTE_MS;
+var watchers = /* @__PURE__ */ new Map();
+var rediscoveryTimer = null;
+var triggerTimer = null;
+var started = false;
+/** Discovery options threaded into every `discoverCollections` /
+*  `loadCollection` / `sweepStaleActiveEntries` call. Production: empty
+*  (live workspace). Tests: `{ workspaceRoot, userSkillsDir }` pointing
+*  at a fixture tree. Module-level so per-event handlers can read it
+*  without threading through every signature. */
+var discoveryOpts = {};
+var itemSlots = /* @__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. */
+async function startCollectionWatchers(opts = {}) {
+	if (started) return;
+	discoveryOpts = opts.discoveryOpts ?? {};
+	try {
+		await sweepStaleActiveEntries(discoveryOpts);
+		await syncWatchers();
+		const intervalMs = opts.rediscoveryIntervalMs === void 0 ? REDISCOVERY_INTERVAL_MS : opts.rediscoveryIntervalMs;
+		if (intervalMs !== null) {
+			rediscoveryTimer = setInterval(() => {
+				syncWatchers().catch((err) => {
+					log().warn("watcher rediscovery failed", { error: errMsg(err) });
+				});
+			}, intervalMs);
+			rediscoveryTimer.unref();
+		}
+		const triggerMs = opts.triggerTickIntervalMs === void 0 ? TRIGGER_TICK_INTERVAL_MS : opts.triggerTickIntervalMs;
+		if (triggerMs !== null) {
+			triggerTimer = setInterval(() => {
+				tickTimeTriggers().catch((err) => {
+					log().warn("watcher trigger tick failed", { error: errMsg(err) });
+				});
+			}, triggerMs);
+			triggerTimer.unref();
+		}
+		started = true;
+	} catch (err) {
+		discoveryOpts = {};
+		throw err;
+	}
+}
+/** Tear down every watcher and stop the intervals. Used by tests;
+*  production never calls this (process exit reclaims the fds). Resets
+*  `started` so a subsequent `startCollectionWatchers` re-mounts. */
+async function stopCollectionWatchers() {
+	if (rediscoveryTimer) {
+		clearInterval(rediscoveryTimer);
+		rediscoveryTimer = null;
+	}
+	if (triggerTimer) {
+		clearInterval(triggerTimer);
+		triggerTimer = null;
+	}
+	for (const watcher of watchers.values()) try {
+		watcher.watcher.close();
+	} catch {}
+	watchers.clear();
+	itemSlots.clear();
+	discoveryOpts = {};
+	started = false;
+}
+/** Test-only: manually trigger one rediscovery + reconcile pass. */
+async function _syncWatchersForTesting() {
+	await syncWatchers();
+}
+/** Test-only: drive one wall-clock tick synchronously, with an optional
+*  injected clock. */
+async function _tickTimeTriggersForTesting(now) {
+	await tickTimeTriggers(now);
+}
+/** Re-reconcile every watched collection that depends on the clock — i.e.
+*  declares `triggerField` (a bell that fires at a date) and/or `spawn`
+*  (recurrence whose successors come due over time). Collections with
+*  neither are skipped. Idempotent. The schema is parsed back from the
+*  watcher's cached `schemaJson` to avoid a per-tick disk read. */
+async function tickTimeTriggers(now = /* @__PURE__ */ new Date()) {
+	for (const entry of watchers.values()) {
+		let schema;
+		try {
+			schema = JSON.parse(entry.schemaJson);
+		} catch (err) {
+			log().warn("trigger tick: bad cached schema", {
+				slug: entry.slug,
+				error: errMsg(err)
+			});
+			continue;
+		}
+		if (!schema.triggerField && !schema.spawn) continue;
+		await reconcileAllItems(entry.slug, schema, entry.dataDir, discoveryOpts, now);
+	}
+}
+/** Reconcile the watcher set against the currently-discovered
+*  collections. Adds watchers for new slugs (with a boot reconcile of
+*  their items), drops watchers for vanished slugs, and re-reconciles
+*  items for collections whose schema changed. Runs a final sweep when
+*  this tick changed the watcher set or any schema. */
+async function syncWatchers() {
+	let collections;
+	try {
+		collections = await require_server.discoverCollections(discoveryOpts);
+	} catch (err) {
+		log().warn("watcher discover failed", { error: errMsg(err) });
+		return;
+	}
+	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);
+}
+function stopVanishedWatchers(liveSlugs) {
+	let mutated = false;
+	for (const slug of [...watchers.keys()]) {
+		if (liveSlugs.has(slug)) continue;
+		const watcher = watchers.get(slug);
+		if (watcher) try {
+			watcher.watcher.close();
+		} catch {}
+		watchers.delete(slug);
+		mutated = true;
+		log().info("watcher stopped", { slug });
+	}
+	return mutated;
+}
+/** Re-reconcile already-watched collections whose schema changed since
+*  the last tick. New collections fall through to `startNewWatchers`. */
+async function reconcileChangedSchemas(collections) {
+	let mutated = false;
+	for (const collection of collections) {
+		const existing = watchers.get(collection.slug);
+		if (!existing) continue;
+		const nextJson = JSON.stringify(collection.schema);
+		if (existing.schemaJson === nextJson) continue;
+		existing.schemaJson = nextJson;
+		log().info("watcher schema changed, re-reconciling", { slug: collection.slug });
+		await reconcileAllItems(collection.slug, collection.schema, collection.dataDir, discoveryOpts);
+		mutated = true;
+	}
+	return mutated;
+}
+async function startNewWatchers(collections) {
+	let mutated = false;
+	for (const collection of collections) {
+		if (watchers.has(collection.slug)) continue;
+		await startWatcherFor(collection.slug, collection.schema, collection.dataDir);
+		mutated = true;
+	}
+	return mutated;
+}
+async function startWatcherFor(slug, schema, dataDir) {
+	try {
+		await (0, node_fs_promises.mkdir)(dataDir, { recursive: true });
+		await reconcileAllItems(slug, schema, dataDir, 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)
+		});
+		log().info("watcher started", {
+			slug,
+			dataDir
+		});
+	} catch (err) {
+		log().warn("watcher start failed", {
+			slug,
+			error: errMsg(err)
+		});
+	}
+}
+/** 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(slug, schema, dataDir, itemId) {
+	return scheduleItemReconcile(slug, schema, dataDir, itemId);
+}
+function scheduleItemReconcile(slug, schema, dataDir, itemId) {
+	const key = `${slug}\x00${itemId}`;
+	const existing = itemSlots.get(key);
+	if (existing) {
+		existing.pending = true;
+		return existing.running;
+	}
+	const slot = {
+		running: Promise.resolve(),
+		pending: false
+	};
+	slot.running = (async () => {
+		try {
+			let keepGoing = true;
+			while (keepGoing) {
+				slot.pending = false;
+				await reconcileItem(slug, schema, dataDir, itemId, discoveryOpts);
+				keepGoing = slot.pending;
+			}
+		} finally {
+			itemSlots.delete(key);
+		}
+	})();
+	itemSlots.set(key, slot);
+	return slot.running;
+}
+/** 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_server.loadCollection(slug, discoveryOpts);
+	if (!collection) return;
+	if (filename === null) {
+		await reconcileAllItems(slug, collection.schema, collection.dataDir, discoveryOpts);
+		await sweepStaleActiveEntries(discoveryOpts);
+		return;
+	}
+	const name = typeof filename === "string" ? filename : filename.toString("utf-8");
+	if (!name.endsWith(".json") || name.startsWith(".")) return;
+	const itemId = name.slice(0, -5);
+	await scheduleItemReconcile(slug, collection.schema, collection.dataDir, itemId);
+}
+//#endregion
+exports._resetReconcilerLocksForTesting = _resetReconcilerLocksForTesting;
+exports._scheduleItemReconcileForTesting = _scheduleItemReconcileForTesting;
+exports._syncWatchersForTesting = _syncWatchersForTesting;
+exports._tickTimeTriggersForTesting = _tickTimeTriggersForTesting;
+exports.clearItemNotification = clearItemNotification;
+exports.configureCollectionWatchers = configureCollectionWatchers;
+exports.itemIsDone = itemIsDone;
+exports.reconcileAllItems = reconcileAllItems;
+exports.reconcileItem = reconcileItem;
+exports.resetCollectionWatchersConfig = resetCollectionWatchersConfig;
+exports.resolveDisplayLabel = resolveDisplayLabel;
+exports.startCollectionWatchers = startCollectionWatchers;
+exports.stopCollectionWatchers = stopCollectionWatchers;
+exports.sweepStaleActiveEntries = sweepStaleActiveEntries;
+
+//# sourceMappingURL=index.cjs.map