@mulmoclaude/core 0.2.7 → 0.2.9

package/dist/notifier/types.d.ts

@@ -1,118 +0,0 @@
-/** Two notification shapes, distinguished by who fires the close call:
- *
- *    `fyi`    — informational. The host (bell panel) clears it when the
- *               user dismisses the row. No deep-link target.
- *    `action` — pending obligation. The plugin clears it when the
- *               underlying domain state changes (the user paid the tax,
- *               viewed the digest, etc.). The bell row navigates to
- *               `navigateTarget` on click.
- *
- *  The engine reads `lifecycle` only to enforce two publish-time rules
- *  (everything downstream — pubsub fan-out, persistence, history — is
- *  lifecycle-blind):
- *
- *    1. `action` requires a non-empty `navigateTarget`. Without one,
- *       clicking the row does nothing and the entry is a degraded fyi.
- *    2. `action` cannot use `info` severity. A low-priority obligation
- *       is incoherent — fyi if it's a ping, `nudge`/`urgent` if it's a
- *       real obligation worth a landing page.
- *
- *  Both rules are mirrored in the HTTP layer so plugin-runtime callers
- *  and HTTP callers hit the same wall. */
-export declare const NOTIFIER_LIFECYCLES: readonly ["fyi", "action"];
-export type NotifierLifecycle = (typeof NOTIFIER_LIFECYCLES)[number];
-/** Severity drives badge color (gray / amber / red, worst-wins) and
- *  in a future iteration channel routing. Mostly stored verbatim by
- *  the engine; the one engine-visible interaction is the rule that
- *  `action` lifecycle cannot pair with `info` severity (see
- *  `NotifierLifecycle` above). */
-export declare const NOTIFIER_SEVERITIES: readonly ["info", "nudge", "urgent"];
-export type NotifierSeverity = (typeof NOTIFIER_SEVERITIES)[number];
-export interface NotifierEntry<TPluginData = unknown> {
-    /** Engine-assigned UUID. Generated synchronously inside `publish()`
-     *  so the caller can use it before persistence completes. */
-    id: string;
-    /** Plugin namespace (e.g. `"encore"`, `"debug__system"`). The
-     *  engine never inspects it — used only for `listFor()` filtering
-     *  and as a UI grouping key. */
-    pluginPkg: string;
-    severity: NotifierSeverity;
-    lifecycle?: NotifierLifecycle;
-    title: string;
-    body?: string;
-    /** Optional in-app deep-link target (relative URL). The bell popup
-     *  routes here on row click, with `&notificationId=<id>` appended
-     *  so the landing page can identify which entry to clear. The
-     *  engine doesn't read this — it's a UI hint stored on the entry. */
-    navigateTarget?: string;
-    /** Opaque to the engine. Round-trips through JSON unchanged; only
-     *  the originating plugin's UI knows the shape. */
-    pluginData?: TPluginData;
-    /** ISO-8601 timestamp set at `publish()` time. */
-    createdAt: string;
-}
-/** A history entry — a `NotifierEntry` after it has been cleared or
- *  cancelled, with the terminal type and timestamp recorded. The
- *  bell popup's "History" section renders these read-only. */
-export interface NotifierHistoryEntry<TPluginData = unknown> extends NotifierEntry<TPluginData> {
-    terminalType: "cleared" | "cancelled";
-    terminalAt: string;
-}
-/** Caller-supplied input for `publish()`. The engine fills in `id`
- *  and `createdAt`; everything else flows through verbatim.
- *
- *  Two publish-time rules apply to `action` lifecycle (see
- *  `NotifierLifecycle`):
- *
- *    - `navigateTarget` MUST be a non-empty string.
- *    - `severity` MUST NOT be `"info"`.
- *
- *  Violations cause `publish()` to throw. Currently expressed as
- *  runtime validation rather than a discriminated-union type, so the
- *  fields below are all individually optional / loose at the
- *  type-level. */
-export interface PublishInput<TPluginData = unknown> {
-    pluginPkg: string;
-    severity: NotifierSeverity;
-    title: string;
-    body?: string;
-    lifecycle?: NotifierLifecycle;
-    navigateTarget?: string;
-    pluginData?: TPluginData;
-}
-/** On-disk shape of `~/mulmoclaude/data/notifier/active.json`. Holds
- *  only entries that haven't been cleared or cancelled — the file is
- *  a snapshot, not an event log. */
-export interface NotifierFile {
-    entries: Record<string, NotifierEntry>;
-}
-/** On-disk shape of `~/mulmoclaude/data/notifier/history.json`. Array
- *  of terminated entries newest-first, capped at `HISTORY_CAP` with
- *  FIFO eviction (push at index 0, slice from the tail). */
-export interface NotifierHistoryFile {
-    entries: NotifierHistoryEntry[];
-}
-/** History size cap. The bell popup's History section renders this
- *  many entries; older ones fall off when new terminations land. */
-export declare const HISTORY_CAP = 50;
-/** Pub-sub event published on the host's notifier channel after every
- *  successful state change. Discriminated union — subscribers switch
- *  on `type` to keep TypeScript narrowing the rest of the payload.
- *
- *  `updated` carries the post-mutation entry — the receiver swaps
- *  the matching `id` in their local active set. Reserved for in-
- *  place edits via `updateForPlugin`; no history record is written
- *  because the entry is still active, just with refreshed content. */
-export type NotifierEvent = {
-    type: "published";
-    entry: NotifierEntry;
-} | {
-    type: "cleared";
-    id: string;
-} | {
-    type: "cancelled";
-    id: string;
-} | {
-    type: "updated";
-    entry: NotifierEntry;
-};

package/dist/notifier/validate.d.ts

@@ -1,17 +0,0 @@
-import { PublishInput } from './types.js';
-/** Hard caps on publish-input fields. The engine reads each entry on
- *  every list/get call (no in-memory cache), so unbounded fields hurt
- *  every reader. Caps chosen to be generous for legitimate UX copy
- *  while bounding active.json growth: a notification fundamentally is
- *  a short blurb, not a document. */
-export declare const NOTIFIER_LIMITS: {
-    readonly titleMax: 200;
-    readonly bodyMax: 4000;
-    readonly navigateTargetMax: 1000;
-    readonly pluginDataMaxBytes: number;
-};
-/** Validate a `PublishInput`. Returns `null` if OK, or a
- *  human-readable error string. Order matters — shape/size errors are
- *  reported before lifecycle/severity coherence errors so the message
- *  the caller sees points at the most fundamental problem first. */
-export declare function validatePublishInput(input: PublishInput): string | null;

package/dist/notifier-bS8IEeLA.cjs

@@ -1,577 +0,0 @@
-let node_fs = require("node:fs");
-let node_crypto = require("node:crypto");
-//#region src/notifier/types.ts
-/** Two notification shapes, distinguished by who fires the close call:
-*
-*    `fyi`    — informational. The host (bell panel) clears it when the
-*               user dismisses the row. No deep-link target.
-*    `action` — pending obligation. The plugin clears it when the
-*               underlying domain state changes (the user paid the tax,
-*               viewed the digest, etc.). The bell row navigates to
-*               `navigateTarget` on click.
-*
-*  The engine reads `lifecycle` only to enforce two publish-time rules
-*  (everything downstream — pubsub fan-out, persistence, history — is
-*  lifecycle-blind):
-*
-*    1. `action` requires a non-empty `navigateTarget`. Without one,
-*       clicking the row does nothing and the entry is a degraded fyi.
-*    2. `action` cannot use `info` severity. A low-priority obligation
-*       is incoherent — fyi if it's a ping, `nudge`/`urgent` if it's a
-*       real obligation worth a landing page.
-*
-*  Both rules are mirrored in the HTTP layer so plugin-runtime callers
-*  and HTTP callers hit the same wall. */
-var NOTIFIER_LIFECYCLES = ["fyi", "action"];
-/** Severity drives badge color (gray / amber / red, worst-wins) and
-*  in a future iteration channel routing. Mostly stored verbatim by
-*  the engine; the one engine-visible interaction is the rule that
-*  `action` lifecycle cannot pair with `info` severity (see
-*  `NotifierLifecycle` above). */
-var NOTIFIER_SEVERITIES = [
-	"info",
-	"nudge",
-	"urgent"
-];
-/** History size cap. The bell popup's History section renders this
-*  many entries; older ones fall off when new terminations land. */
-var HISTORY_CAP = 50;
-//#endregion
-//#region src/notifier/store.ts
-function isNotFoundError(err) {
-	return typeof err === "object" && err !== null && err.code === "ENOENT";
-}
-/** Read the active-entries file. Returns an empty store when the file
-*  doesn't exist yet (first ever call on a fresh workspace). Any other
-*  read or parse failure throws — the caller has to decide whether to
-*  surface or recover, since silently treating "malformed file" as
-*  "no entries" would lose data. */
-async function loadActive(filePath) {
-	let text;
-	try {
-		text = await node_fs.promises.readFile(filePath, "utf-8");
-	} catch (err) {
-		if (isNotFoundError(err)) return { entries: {} };
-		throw err;
-	}
-	const parsed = JSON.parse(text);
-	if (typeof parsed !== "object" || parsed === null || !("entries" in parsed)) throw new Error(`notifier: malformed active.json at ${filePath}`);
-	const { entries } = parsed;
-	if (typeof entries !== "object" || entries === null || Array.isArray(entries)) throw new Error(`notifier: malformed active.json at ${filePath}`);
-	return parsed;
-}
-/** Write the active-entries file via the injected atomic writer so a
-*  half-written file is never visible to readers. The caller serialises
-*  writes (engine.ts queues mutations) — this function makes no
-*  concurrency guarantees of its own. */
-async function saveActive(writeJson, filePath, state) {
-	await writeJson(filePath, state);
-}
-/** Read the history file. Empty array on first run. Same parse-error
-*  policy as `loadActive`. */
-async function loadHistory(filePath) {
-	let text;
-	try {
-		text = await node_fs.promises.readFile(filePath, "utf-8");
-	} catch (err) {
-		if (isNotFoundError(err)) return { entries: [] };
-		throw err;
-	}
-	const parsed = JSON.parse(text);
-	if (typeof parsed !== "object" || parsed === null || !("entries" in parsed) || !Array.isArray(parsed.entries)) throw new Error(`notifier: malformed history.json at ${filePath}`);
-	return parsed;
-}
-async function saveHistory(writeJson, filePath, state) {
-	await writeJson(filePath, state);
-}
-//#endregion
-//#region src/notifier/validate.ts
-/** Hard caps on publish-input fields. The engine reads each entry on
-*  every list/get call (no in-memory cache), so unbounded fields hurt
-*  every reader. Caps chosen to be generous for legitimate UX copy
-*  while bounding active.json growth: a notification fundamentally is
-*  a short blurb, not a document. */
-var NOTIFIER_LIMITS = {
-	titleMax: 200,
-	bodyMax: 4e3,
-	navigateTargetMax: 1e3,
-	pluginDataMaxBytes: 16 * 1024
-};
-function validateTitle(title) {
-	if (typeof title !== "string" || title.length === 0) return "title must be a non-empty string";
-	if (title.length > NOTIFIER_LIMITS.titleMax) return `title exceeds max length of ${NOTIFIER_LIMITS.titleMax} chars`;
-	return null;
-}
-function validateBody(body) {
-	if (body === void 0) return null;
-	if (body.length > NOTIFIER_LIMITS.bodyMax) return `body exceeds max length of ${NOTIFIER_LIMITS.bodyMax} chars`;
-	return null;
-}
-function validateNavigateTarget(target) {
-	if (target === void 0) return null;
-	if (target.length === 0) return "navigateTarget must be a non-empty relative path when set";
-	if (target.length > NOTIFIER_LIMITS.navigateTargetMax) return `navigateTarget exceeds max length of ${NOTIFIER_LIMITS.navigateTargetMax} chars`;
-	if (!target.startsWith("/") || target.startsWith("//")) return "navigateTarget must be a relative path beginning with a single '/' (no scheme, no '//')";
-	return null;
-}
-function validatePluginData(pluginData) {
-	if (pluginData === void 0) return null;
-	let serialized;
-	try {
-		serialized = JSON.stringify(pluginData);
-	} catch (err) {
-		return `pluginData is not JSON-serialisable: ${String(err)}`;
-	}
-	if (typeof serialized !== "string") return "pluginData is not JSON-serialisable";
-	if (serialized.length > NOTIFIER_LIMITS.pluginDataMaxBytes) return `pluginData JSON exceeds ${NOTIFIER_LIMITS.pluginDataMaxBytes} bytes`;
-	return null;
-}
-function validateActionCoherence(input) {
-	if (input.lifecycle !== "action") return null;
-	if (input.severity === "info") return "action lifecycle is incompatible with info severity (use fyi for low-priority pings)";
-	if (typeof input.navigateTarget !== "string" || input.navigateTarget.length === 0) return "action lifecycle requires a non-empty navigateTarget";
-	return null;
-}
-/** Validate a `PublishInput`. Returns `null` if OK, or a
-*  human-readable error string. Order matters — shape/size errors are
-*  reported before lifecycle/severity coherence errors so the message
-*  the caller sees points at the most fundamental problem first. */
-function validatePublishInput(input) {
-	return validateTitle(input.title) ?? validateBody(input.body) ?? validateNavigateTarget(input.navigateTarget) ?? validatePluginData(input.pluginData) ?? validateActionCoherence(input);
-}
-//#endregion
-//#region src/notifier/engine.ts
-var NOOP_LOG = {
-	warn: () => {},
-	error: () => {}
-};
-var config = null;
-var activeFilePath = "";
-var historyFilePath = "";
-function logger() {
-	return config?.log ?? NOOP_LOG;
-}
-/** Wire the engine's I/O deps. Call once at startup, before the first
-*  mutation. Does NOT set file paths — those are set independently via
-*  `setNotifierFilePaths` so a host can bind production paths at module
-*  load and a test can override them without re-supplying the deps. */
-function configureNotifier(injected) {
-	config = injected;
-}
-var listeners = [];
-/** Register an in-process listener for engine events. Returns an
-*  unsubscribe function the caller can use during teardown. */
-function onEvent(listener) {
-	listeners.push(listener);
-	return () => {
-		const idx = listeners.indexOf(listener);
-		if (idx >= 0) listeners.splice(idx, 1);
-	};
-}
-function emit(event) {
-	for (const listener of listeners) try {
-		listener(event);
-	} catch (err) {
-		logger().error("in-process listener failed", {
-			type: event.type,
-			error: String(err)
-		});
-	}
-	if (!config) {
-		logger().warn("emit before init", { type: event.type });
-		return;
-	}
-	try {
-		config.publishEvent(event);
-	} catch (err) {
-		logger().error("emit failed", {
-			type: event.type,
-			error: String(err)
-		});
-	}
-}
-var writing = false;
-var waiters = [];
-/** Point the engine at its active/history files. Resets the write
-*  queue, so callers must not have in-flight mutations. The host calls
-*  this once with the workspace paths; tests call it per-case with temp
-*  files. */
-function setNotifierFilePaths(paths) {
-	activeFilePath = paths.active;
-	historyFilePath = paths.history;
-	writing = false;
-	waiters = [];
-}
-/** Test-only: clear config + queue so each suite starts clean. */
-function resetNotifier() {
-	config = null;
-	activeFilePath = "";
-	historyFilePath = "";
-	writing = false;
-	waiters = [];
-	listeners.length = 0;
-}
-function requireWriteJson() {
-	if (!config) throw new Error("notifier: configureNotifier() not called");
-	return config.writeJson;
-}
-function applyBatchMutations(batch, state) {
-	return batch.map((waiter) => {
-		try {
-			return {
-				ok: true,
-				outcome: waiter.mutate(state)
-			};
-		} catch (err) {
-			return {
-				ok: false,
-				error: err
-			};
-		}
-	});
-}
-function collectEvents(results) {
-	const events = [];
-	for (const result of results) if (result.ok && result.outcome !== null) events.push(result.outcome.event);
-	return events;
-}
-function collectHistoryEntries(results) {
-	const entries = [];
-	for (const result of results) if (result.ok && result.outcome !== null && result.outcome.historyEntry) entries.push(result.outcome.historyEntry);
-	return entries;
-}
-function settleBatch(batch, results) {
-	for (let index = 0; index < batch.length; index += 1) {
-		const result = results[index];
-		if (result.ok) batch[index].resolve();
-		else batch[index].reject(result.error);
-	}
-}
-function rejectBatch(batch, err) {
-	for (const waiter of batch) waiter.reject(err);
-}
-async function persistHistory(newEntries) {
-	const existing = await loadHistory(historyFilePath);
-	const merged = [...newEntries.slice().reverse(), ...existing.entries].slice(0, 50);
-	await saveHistory(requireWriteJson(), historyFilePath, { entries: merged });
-}
-async function processBatch(batch) {
-	let state;
-	try {
-		state = await loadActive(activeFilePath);
-	} catch (err) {
-		logger().error("load failed", { error: String(err) });
-		rejectBatch(batch, err);
-		return;
-	}
-	const results = applyBatchMutations(batch, state);
-	const events = collectEvents(results);
-	const historyEntries = collectHistoryEntries(results);
-	if (events.length > 0) {
-		try {
-			await saveActive(requireWriteJson(), activeFilePath, state);
-		} catch (err) {
-			logger().error("active write failed", { error: String(err) });
-			rejectBatch(batch, err);
-			return;
-		}
-		if (historyEntries.length > 0) try {
-			await persistHistory(historyEntries);
-		} catch (err) {
-			logger().error("history write failed", { error: String(err) });
-		}
-		for (const event of events) emit(event);
-	}
-	settleBatch(batch, results);
-}
-async function drain() {
-	writing = true;
-	try {
-		while (waiters.length > 0) {
-			const batch = waiters;
-			waiters = [];
-			await processBatch(batch);
-		}
-	} finally {
-		writing = false;
-	}
-}
-function enqueue(mutate) {
-	return new Promise((resolve, reject) => {
-		waiters.push({
-			mutate,
-			resolve,
-			reject
-		});
-		if (!writing) drain();
-	});
-}
-function removeEntry(state, entryId) {
-	const { [entryId]: __removed, ...remaining } = state.entries;
-	return remaining;
-}
-function buildHistoryEntry(entry, terminalType) {
-	return {
-		...entry,
-		terminalType,
-		terminalAt: (/* @__PURE__ */ new Date()).toISOString()
-	};
-}
-async function publish(input) {
-	const validationError = validatePublishInput(input);
-	if (validationError) throw new Error(`notifier.publish: ${validationError}`);
-	const entryId = (0, node_crypto.randomUUID)();
-	const entry = {
-		id: entryId,
-		pluginPkg: input.pluginPkg,
-		severity: input.severity,
-		lifecycle: input.lifecycle,
-		title: input.title,
-		body: input.body,
-		navigateTarget: input.navigateTarget,
-		pluginData: input.pluginData,
-		createdAt: (/* @__PURE__ */ new Date()).toISOString()
-	};
-	await enqueue((state) => {
-		state.entries[entryId] = entry;
-		return { event: {
-			type: "published",
-			entry
-		} };
-	});
-	return { id: entryId };
-}
-async function clear(entryId) {
-	await enqueue((state) => {
-		const entry = state.entries[entryId];
-		if (!entry) return null;
-		state.entries = removeEntry(state, entryId);
-		return {
-			event: {
-				type: "cleared",
-				id: entryId
-			},
-			historyEntry: buildHistoryEntry(entry, "cleared")
-		};
-	});
-}
-async function cancel(entryId) {
-	await enqueue((state) => {
-		const entry = state.entries[entryId];
-		if (!entry) return null;
-		state.entries = removeEntry(state, entryId);
-		return {
-			event: {
-				type: "cancelled",
-				id: entryId
-			},
-			historyEntry: buildHistoryEntry(entry, "cancelled")
-		};
-	});
-}
-/** In-place update for an active entry. Only the fields present on
-*  `patch` are rewritten; `id`, `pluginPkg`, `lifecycle`, and
-*  `createdAt` stay fixed. Emits a single `"updated"` event with the
-*  post-mutation entry — no history record is written because the
-*  entry is still active, just with refreshed content.
-*
-*  No-ops (no throw) when the id is unknown, the entry belongs to a
-*  different plugin, or the merged shape would violate
-*  `validatePublishInput`. The silent skip matches `clearForPlugin`'s
-*  isolation semantics; validation failures are logged for diagnosis. */
-async function updateForPlugin(pluginPkg, entryId, patch) {
-	await enqueue((state) => {
-		const entry = state.entries[entryId];
-		if (!entry) return null;
-		if (entry.pluginPkg !== pluginPkg) return null;
-		const next = {
-			...entry,
-			...patch.severity !== void 0 ? { severity: patch.severity } : {},
-			...patch.title !== void 0 ? { title: patch.title } : {},
-			...patch.body !== void 0 ? { body: patch.body } : {},
-			...patch.navigateTarget !== void 0 ? { navigateTarget: patch.navigateTarget } : {},
-			...patch.pluginData !== void 0 ? { pluginData: patch.pluginData } : {}
-		};
-		const validationError = validatePublishInput({
-			pluginPkg: next.pluginPkg,
-			severity: next.severity,
-			title: next.title,
-			body: next.body,
-			lifecycle: next.lifecycle,
-			navigateTarget: next.navigateTarget,
-			pluginData: next.pluginData
-		});
-		if (validationError) {
-			logger().warn("update rejected by validation", {
-				entryId,
-				pluginPkg,
-				error: validationError
-			});
-			return null;
-		}
-		state.entries[entryId] = next;
-		return { event: {
-			type: "updated",
-			entry: next
-		} };
-	});
-}
-/** Plugin-scoped point lookup. Returns the entry by id, but only if it
-*  belongs to the caller's plugin; otherwise undefined. Cross-plugin
-*  reads return undefined for isolation — same property as
-*  `clearForPlugin` / `updateForPlugin`. */
-async function getForPlugin(pluginPkg, entryId) {
-	const entry = (await loadActive(activeFilePath)).entries[entryId];
-	if (!entry) return void 0;
-	if (entry.pluginPkg !== pluginPkg) return void 0;
-	return entry;
-}
-/** Plugin-scoped clear. Same as `clear` but no-ops if the entry's
-*  `pluginPkg` doesn't match the caller's, so a plugin can't dismiss
-*  another plugin's notification by guessing or scraping its id. */
-async function clearForPlugin(pluginPkg, entryId) {
-	await enqueue((state) => {
-		const entry = state.entries[entryId];
-		if (!entry) return null;
-		if (entry.pluginPkg !== pluginPkg) return null;
-		state.entries = removeEntry(state, entryId);
-		return {
-			event: {
-				type: "cleared",
-				id: entryId
-			},
-			historyEntry: buildHistoryEntry(entry, "cleared")
-		};
-	});
-}
-async function get(entryId) {
-	return (await loadActive(activeFilePath)).entries[entryId];
-}
-async function listFor(pluginPkg) {
-	const state = await loadActive(activeFilePath);
-	return Object.values(state.entries).filter((entry) => entry.pluginPkg === pluginPkg);
-}
-async function listAll() {
-	const state = await loadActive(activeFilePath);
-	return Object.values(state.entries);
-}
-async function listHistory() {
-	return (await loadHistory(historyFilePath)).entries;
-}
-//#endregion
-Object.defineProperty(exports, "HISTORY_CAP", {
-	enumerable: true,
-	get: function() {
-		return HISTORY_CAP;
-	}
-});
-Object.defineProperty(exports, "NOTIFIER_LIFECYCLES", {
-	enumerable: true,
-	get: function() {
-		return NOTIFIER_LIFECYCLES;
-	}
-});
-Object.defineProperty(exports, "NOTIFIER_LIMITS", {
-	enumerable: true,
-	get: function() {
-		return NOTIFIER_LIMITS;
-	}
-});
-Object.defineProperty(exports, "NOTIFIER_SEVERITIES", {
-	enumerable: true,
-	get: function() {
-		return NOTIFIER_SEVERITIES;
-	}
-});
-Object.defineProperty(exports, "cancel", {
-	enumerable: true,
-	get: function() {
-		return cancel;
-	}
-});
-Object.defineProperty(exports, "clear", {
-	enumerable: true,
-	get: function() {
-		return clear;
-	}
-});
-Object.defineProperty(exports, "clearForPlugin", {
-	enumerable: true,
-	get: function() {
-		return clearForPlugin;
-	}
-});
-Object.defineProperty(exports, "configureNotifier", {
-	enumerable: true,
-	get: function() {
-		return configureNotifier;
-	}
-});
-Object.defineProperty(exports, "get", {
-	enumerable: true,
-	get: function() {
-		return get;
-	}
-});
-Object.defineProperty(exports, "getForPlugin", {
-	enumerable: true,
-	get: function() {
-		return getForPlugin;
-	}
-});
-Object.defineProperty(exports, "listAll", {
-	enumerable: true,
-	get: function() {
-		return listAll;
-	}
-});
-Object.defineProperty(exports, "listFor", {
-	enumerable: true,
-	get: function() {
-		return listFor;
-	}
-});
-Object.defineProperty(exports, "listHistory", {
-	enumerable: true,
-	get: function() {
-		return listHistory;
-	}
-});
-Object.defineProperty(exports, "onEvent", {
-	enumerable: true,
-	get: function() {
-		return onEvent;
-	}
-});
-Object.defineProperty(exports, "publish", {
-	enumerable: true,
-	get: function() {
-		return publish;
-	}
-});
-Object.defineProperty(exports, "resetNotifier", {
-	enumerable: true,
-	get: function() {
-		return resetNotifier;
-	}
-});
-Object.defineProperty(exports, "setNotifierFilePaths", {
-	enumerable: true,
-	get: function() {
-		return setNotifierFilePaths;
-	}
-});
-Object.defineProperty(exports, "updateForPlugin", {
-	enumerable: true,
-	get: function() {
-		return updateForPlugin;
-	}
-});
-Object.defineProperty(exports, "validatePublishInput", {
-	enumerable: true,
-	get: function() {
-		return validatePublishInput;
-	}
-});
-
-//# sourceMappingURL=notifier-bS8IEeLA.cjs.map