@classytic/arc-notifications 0.6.3 → 0.9.0

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { BaseChannel, ChannelConfig, DeliveryLog, DeliveryLogEntry, NotificationPayload, NotificationService, NotificationServiceConfig, QueueAdapter, Recipient, SendResult, TemplateResolver } from "@classytic/notifications";
 import { JobDefinition, JobDispatcher } from "@classytic/arc/integrations/jobs";
-import { ArcModule } from "@classytic/arc/factory";
+import { ArcModule, EventHandlerDefinition } from "@classytic/arc/factory";
 import { PermissionCheck } from "@classytic/arc/permissions";
 import { FastifyInstance, FastifyRequest } from "fastify";
 import { DomainEvent } from "@classytic/primitives/events";
@@ -339,6 +339,18 @@ interface NotificationTriggerOverrideDoc {
    * answer is a host-supplied predicate, never an expression DSL.
    */
   sourceChannels?: string[] | null;
+  /**
+   * Literal addresses to notify IN ADDITION to the role recipients.
+   *
+   * `recipients` holds ROLES, which only reaches people who hold an account.
+   * The person who wants order mail — an owner, an accountant, a shared
+   * ops@ inbox — often has no dashboard login at all, so a role list cannot
+   * express them.
+   *
+   * ADDITIVE, never a replacement: adding an address must not silence the staff
+   * feed, which is what substituting for `recipients` would do.
+   */
+  recipientEmails?: string[] | null;
   /** Copy overrides. Unset fields fall back to the code template. */
   title?: string | null;
   message?: string | null;
@@ -395,6 +407,8 @@ interface EffectiveTriggerSettings {
   channels: NotificationChannel[];
   /** `null` = unrestricted. See {@link NotificationTriggerOverrideDoc.sourceChannels}. */
   sourceChannels: string[] | null;
+  /** Extra literal addresses, ADDED to the role recipients. `[]` when none. */
+  recipientEmails: string[];
   title: string;
   message: string;
   priority?: "low" | "normal" | "high" | undefined;
@@ -405,6 +419,21 @@ interface CodeTriggerDefaults {
   title: string;
   message: string;
   priority?: "low" | "normal" | "high" | undefined;
+  /**
+   * The trigger's OWN origin restriction — `null`/absent means unrestricted.
+   *
+   * Every other field here is a code default an operator's row REPLACES. This
+   * one was the exception: the merge below hardcoded `?? null`, so a deployment
+   * could not state "a new-order alert is for web orders, not for the till" and
+   * every deployment shipped unscoped until someone hand-configured the UI.
+   *
+   * That matters most where it is least visible. A branch runs several
+   * registers, and unscoped means every counter sale fans out to every staff
+   * role on every one of them — resolved, written to the feed, and attempted on
+   * each connector, all before the response. The cashier who rang the sale is
+   * already looking at it.
+   */
+  sourceChannels?: readonly string[] | undefined;
 }
 declare function resolveEffectiveSettings(triggerType: string, organizationId: string | null, rows: readonly NotificationTriggerOverrideDoc[], defaults: CodeTriggerDefaults): EffectiveTriggerSettings;
 /**
@@ -700,6 +729,18 @@ declare module "fastify" {
   }
 }
 declare function notificationsModule(config: NotificationsModuleConfig): ArcModule<NotificationService>;
+/**
+ * Triggers as arc `eventHandlers` — what `notifyOn` subscribes, exported so a BRIDGE module can own
+ * the triggers for one producer (`dependsOn: [producer, "notifications"]`) and vanish with it.
+ * `service` is read per dispatch, so a bridge can resolve it from the notifications module's export.
+ */
+declare function notifyTriggerHandlers(options: {
+  /** Handler-name prefix; arc rejects duplicate handler names across the module graph. */
+  readonly name: string;
+  readonly service: () => NotificationService;
+  readonly triggers: readonly NotifyTrigger[];
+  readonly recipientResolver?: RecipientResolver;
+}): EventHandlerDefinition[];
 /** One event → N sends. Exported for direct unit testing. */
 declare function dispatchTrigger(service: NotificationService, trigger: NotifyTrigger, event: DomainEvent, opts?: {
   recipientResolver?: RecipientResolver;
@@ -719,6 +760,11 @@ interface DeliveryLogDoc {
   readonly status: EntryStatus;
   readonly duration: number;
   readonly metadata?: Record<string, unknown>;
+  /**
+   * The organization the delivery belongs to — top-level so a store can index it and a
+   * reader can scope on it. `null` = company-wide (no organization named).
+   */
+  readonly organizationId?: string | null;
   /**
    * The business document this delivery concerned. A STORE MUST INDEX IT —
    * this field exists precisely so "every message about invoice X" is a keyed
@@ -872,6 +918,24 @@ interface NotificationTrigger {
    * boot.
    */
   channels?: readonly NotificationChannel[];
+  /**
+   * Restrict this trigger to events ORIGINATING from these sources — the
+   * deployment's own sales channels (`web` / `pos` / `marketplace`), NOT the
+   * delivery channels above. Two adjacent fields, two vocabularies.
+   *
+   * Absent = unrestricted, which is the historical behaviour and stays the
+   * default. An operator's stored setting REPLACES this, so declaring one
+   * narrows the out-of-the-box noise without taking the choice away.
+   *
+   * State it for any staff alert whose event can originate at a till: a branch
+   * runs several registers, and unscoped means every counter sale is resolved,
+   * written to the feed and attempted on every connector — before the response —
+   * to tell staff about a sale the cashier is already looking at.
+   *
+   * Never `[]`. Empty means "match nothing", which silences the trigger while
+   * looking like a filter; `enabled: false` is how you say that.
+   */
+  sourceChannels?: readonly string[];
   /**
    * Pull dispatch variables out of the event payload.
    *
@@ -1058,4 +1122,4 @@ interface TriggerCatalogEntry {
  */
 type TriggerCatalogPort = () => ReadonlyArray<TriggerCatalogEntry> | Promise<ReadonlyArray<TriggerCatalogEntry>>;
 //#endregion
-export { type CodeTemplates, type CodeTriggerDefaults, type CreateCachedTriggerOverrideStoreOptions, type CreateUnreadCountCacheOptions, DEFAULT_ENTITY_ID_VARS, type DbFirstResolverOptions, type DbFirstTemplateResolver, type DeliveryLogDoc, type EffectiveTriggerSettings, INAPP_DATA_KEY, IN_APP_CHANNEL, type InAppBackfill, type InAppBackfillOptions, InAppChannel, type InAppChannelConfig, type InAppContent, type InAppFeedListOptions, type InAppFeedPage, type InAppFeedRepository, type InAppFeedResourceOptions, type InAppFeedRow, type InAppFeedScope, type InAppPriority, type InAppTemplate, type NotificationAudienceType, type NotificationChannel, type NotificationChannelCatalog, type NotificationDecision, type NotificationExtractResult, type NotificationRecipientContact, type NotificationSkipReason, type NotificationTrigger, type NotificationTriggerOverrideDoc, type NotificationsJob, type NotificationsJobOptions, type NotificationsModuleConfig, type NotifyTrigger, type RealtimePushPort, type RecipientResolver, type RepositoryDeliveryLogOptions, SseChannel, type SseChannelConfig, type StoredTemplate, type TemplateStore, type TemplatesResourceOptions, type TriggerAdapterOptions, type TriggerCatalogEntry, type TriggerCatalogPort, type TriggerOverrideLoader, type TriggerOverrideResolution, type TriggerOverrideStore, type UnreadCountCache, createCachedTriggerOverrideStore, createDbFirstResolver, createInAppBackfill, createNotificationChannelCatalog, createRepositoryDeliveryLog, createUnreadCountCache, dispatchTrigger, evaluateSourceChannel, getRecipientMatrix, getRegisteredEvents, getTriggerByEvent, getTriggersByEvent, inAppFeedResource, notificationsJob, notificationsModule, readInAppContent, renderInApp, resolveEffectiveSettings, templatesResource, toNotifyTrigger, toNotifyTriggers };
+export { type CodeTemplates, type CodeTriggerDefaults, type CreateCachedTriggerOverrideStoreOptions, type CreateUnreadCountCacheOptions, DEFAULT_ENTITY_ID_VARS, type DbFirstResolverOptions, type DbFirstTemplateResolver, type DeliveryLogDoc, type EffectiveTriggerSettings, INAPP_DATA_KEY, IN_APP_CHANNEL, type InAppBackfill, type InAppBackfillOptions, InAppChannel, type InAppChannelConfig, type InAppContent, type InAppFeedListOptions, type InAppFeedPage, type InAppFeedRepository, type InAppFeedResourceOptions, type InAppFeedRow, type InAppFeedScope, type InAppPriority, type InAppTemplate, type NotificationAudienceType, type NotificationChannel, type NotificationChannelCatalog, type NotificationDecision, type NotificationExtractResult, type NotificationRecipientContact, type NotificationSkipReason, type NotificationTrigger, type NotificationTriggerOverrideDoc, type NotificationsJob, type NotificationsJobOptions, type NotificationsModuleConfig, type NotifyTrigger, type RealtimePushPort, type RecipientResolver, type RepositoryDeliveryLogOptions, SseChannel, type SseChannelConfig, type StoredTemplate, type TemplateStore, type TemplatesResourceOptions, type TriggerAdapterOptions, type TriggerCatalogEntry, type TriggerCatalogPort, type TriggerOverrideLoader, type TriggerOverrideResolution, type TriggerOverrideStore, type UnreadCountCache, createCachedTriggerOverrideStore, createDbFirstResolver, createInAppBackfill, createNotificationChannelCatalog, createRepositoryDeliveryLog, createUnreadCountCache, dispatchTrigger, evaluateSourceChannel, getRecipientMatrix, getRegisteredEvents, getTriggerByEvent, getTriggersByEvent, inAppFeedResource, notificationsJob, notificationsModule, notifyTriggerHandlers, readInAppContent, renderInApp, resolveEffectiveSettings, templatesResource, toNotifyTrigger, toNotifyTriggers };

package/dist/index.mjs

@@ -1,7 +1,9 @@
+import { createTtlMemo } from "@classytic/repo-core/cache";
 import { BaseChannel, NotificationService, createSimpleResolver } from "@classytic/notifications";
 import { defineResource } from "@classytic/arc";
 import { NotFoundError } from "@classytic/arc/utils";
 import { defineJob } from "@classytic/arc/integrations/jobs";
+import { scopedValue } from "@classytic/arc/context";
 import { defineModule } from "@classytic/arc/factory";
 //#region src/backfill.ts
 function createInAppBackfill(options) {
@@ -114,23 +116,26 @@ const IN_APP_CHANNEL = "in-app";
 * TTL window.
 */
 function createCachedTriggerOverrideStore(load, options = {}) {
-	const ttlMs = options.ttlMs ?? 3e4;
-	const cache = /* @__PURE__ */ new Map();
+	/**
+	* `createTtlMemo`, never a hand-rolled map: the map wrote its entry AFTER
+	* the await, so the N channel expansions a parallel host dispatches together
+	* all missed. Single flight is what makes the TTL mean anything here.
+	*/
+	const memo = createTtlMemo(load, {
+		ttlMs: options.ttlMs ?? 3e4,
+		keyOf: (organizationId) => organizationId ?? "__company__"
+	});
 	return {
-		async forOrganization(organizationId) {
-			const key = organizationId ?? "__company__";
-			const hit = cache.get(key);
-			if (hit && Date.now() - hit.at < ttlMs) return hit.rows;
-			const rows = await load(organizationId);
-			cache.set(key, {
-				at: Date.now(),
-				rows
-			});
-			return rows;
+		forOrganization(organizationId) {
+			return memo.get(organizationId);
 		},
-		/** Call after a write so an admin sees their change immediately. */
+		/**
+		* Call after a write so an admin sees their change immediately. The
+		* in-process clear completes before this returns; the promise it wraps
+		* only exists to satisfy the adapter contract.
+		*/
 		invalidate() {
-			cache.clear();
+			memo.invalidate();
 		}
 	};
 }
@@ -159,11 +164,36 @@ function resolveEffectiveSettings(triggerType, organizationId, rows, defaults) {
 	const title = pick("title") ?? defaults.title;
 	const message = pick("message") ?? defaults.message;
 	const priority = pick("priority") ?? defaults.priority;
+	/**
+	* Operator row, then the trigger's own default, then unrestricted — the same
+	* ladder every field above uses. It used to stop at `?? null`, discarding a
+	* code default that therefore could not be written at all.
+	*
+	* `?? null`, never `?? []` — the two must stay distinguishable all the way
+	* through. `null` means unrestricted; `[]` would mean "match nothing", and
+	* collapsing one into the other is exactly the widening this field prevents.
+	* A `null` stored by an operator is a deliberate "every source", and it wins
+	* over the code default precisely because they set it.
+	*/
+	/**
+	* PRESENCE, not `??` — the one field where a stored `null` is a decision.
+	*
+	* `pick` collapses `null` into "absent", which is right for every other
+	* setting and wrong here: `null` means "every source", and an operator who
+	* opens a filter must not have it re-narrowed by the code default on the next
+	* read. That is Rule 1 — a default is the fallback for an UNSET value, never
+	* an override of an explicit one.
+	*
+	* Scoped row wins over app-wide, same precedence as `pick`.
+	*/
+	const rowWithField = [scoped, appWide].find((r) => r && "sourceChannels" in r);
+	const sourceChannels = rowWithField ? rowWithField.sourceChannels ?? null : defaults.sourceChannels ? [...defaults.sourceChannels] : null;
 	return {
 		enabled,
 		recipients,
+		recipientEmails: pick("recipientEmails") ?? [],
 		channels,
-		sourceChannels: pick("sourceChannels") ?? null,
+		sourceChannels,
 		title,
 		message,
 		...priority ? { priority } : {}
@@ -277,23 +307,16 @@ function createNotificationChannelCatalog(connectorChannels = []) {
 */
 function createDbFirstResolver(options) {
 	const { store, fallback, cacheTtlMs = 6e4, escape: escapeHtml = true, onError } = options;
-	const cache = /* @__PURE__ */ new Map();
-	const lookup = async (key) => {
-		if (cacheTtlMs > 0) {
-			const hit = cache.get(key);
-			if (hit && Date.now() - hit.at < cacheTtlMs) return hit.doc;
-		}
-		const doc = await store.getByKey(key);
-		if (cacheTtlMs > 0) cache.set(key, {
-			doc,
-			at: Date.now()
-		});
-		return doc;
-	};
+	/**
+	* Single-flight memo: one event's channel expansions resolve the same key in
+	* the same tick, and a `null` row (no draft) is an answer worth keeping. A
+	* store failure rejects every waiter and caches nothing.
+	*/
+	const lookup = createTtlMemo((key) => store.getByKey(key), { ttlMs: cacheTtlMs });
 	const resolver = (async (templateId, data) => {
 		let doc = null;
 		try {
-			doc = await lookup(templateId);
+			doc = await lookup.get(templateId);
 		} catch (err) {
 			onError?.(err, templateId);
 			if (!fallback) throw err;
@@ -308,8 +331,7 @@ function createDbFirstResolver(options) {
 		return fallback(templateId, data);
 	});
 	resolver.invalidate = (key) => {
-		if (key === void 0) cache.clear();
-		else cache.delete(key);
+		lookup.invalidate(key);
 	};
 	return resolver;
 }
@@ -841,26 +863,72 @@ function notificationsModule(config) {
 			return service;
 		},
 		eventHandlers: (fastify) => {
-			const triggers = notifyOn.filter((t) => t.enabled !== false);
-			if (triggers.length === 0) return [];
-			fastify.log.debug(`[arc-notifications] ${triggers.length} trigger(s) subscribed`);
-			return triggers.map((trigger, index) => ({
-				name: `${name}:${trigger.event}#${index}`,
-				event: trigger.event,
-				boundary: true,
-				handler: async (event) => dispatchTrigger(service, trigger, event, { ...recipientResolver ? { recipientResolver } : {} })
-			}));
+			const handlers = notifyTriggerHandlers({
+				name,
+				service: () => service,
+				triggers: notifyOn,
+				...recipientResolver ? { recipientResolver } : {}
+			});
+			if (handlers.length > 0) fastify.log.debug(`[arc-notifications] ${handlers.length} trigger(s) subscribed`);
+			return handlers;
 		}
 	});
 }
+/**
+* Triggers as arc `eventHandlers` — what `notifyOn` subscribes, exported so a BRIDGE module can own
+* the triggers for one producer (`dependsOn: [producer, "notifications"]`) and vanish with it.
+* `service` is read per dispatch, so a bridge can resolve it from the notifications module's export.
+*/
+function notifyTriggerHandlers(options) {
+	const { name, service, recipientResolver } = options;
+	return options.triggers.filter((t) => t.enabled !== false).map((trigger, index) => ({
+		name: `${name}:${trigger.event}#${index}`,
+		event: trigger.event,
+		boundary: true,
+		handler: async (event) => dispatchTrigger(service(), trigger, event, recipientResolver ? { recipientResolver } : {})
+	}));
+}
+const audienceSlot = Symbol("arc-notifications.resolvedAudience");
+/** Content key for an audience — key order must not fragment the memo. */
+function audienceKey(audience) {
+	return JSON.stringify(audience, (_k, v) => v !== null && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => a < b ? -1 : 1)) : v);
+}
+/**
+* Resolve an audience ONCE per dispatch, shared by every expansion that asks.
+*
+* The resolver is a database read in every real host (members by role, then
+* users for contact); N channel expansions of one trigger hand it the same
+* audience. Keyed on CONTENT, so two triggers asking the same question share
+* too. A rejected resolution is dropped so the next expansion retries.
+* Outside a work scope nothing is shared.
+*/
+function resolveAudience(resolver, audience, event) {
+	const memo = scopedValue(audienceSlot, () => /* @__PURE__ */ new Map());
+	if (!memo) return Promise.resolve(resolver(audience, event));
+	const key = audienceKey(audience);
+	const pending = memo.get(key);
+	if (pending) return pending;
+	const created = Promise.resolve(resolver(audience, event));
+	memo.set(key, created);
+	created.catch(() => memo.delete(key));
+	return created;
+}
+/** The `organizationId` an audience names (`{ roles, organizationId, … }`), when it names one. */
+function audienceOrganization(audience) {
+	if (audience === null || typeof audience !== "object") return void 0;
+	const org = audience.organizationId;
+	return typeof org === "string" && org !== "" ? org : void 0;
+}
 /** One event → N sends. Exported for direct unit testing. */
 async function dispatchTrigger(service, trigger, event, opts) {
 	let resolved;
+	let organizationId;
 	if (trigger.recipient) resolved = await trigger.recipient(event);
 	else if (trigger.audience) {
 		const audience = await trigger.audience(event);
 		if (audience === null || audience === void 0) return;
-		resolved = opts?.recipientResolver ? await opts.recipientResolver(audience, event) : void 0;
+		organizationId = audienceOrganization(audience);
+		resolved = opts?.recipientResolver ? await resolveAudience(opts.recipientResolver, audience, event) : void 0;
 	}
 	if (!resolved) return;
 	const recipients = Array.isArray(resolved) ? resolved : [resolved];
@@ -886,6 +954,7 @@ async function dispatchTrigger(service, trigger, event, opts) {
 			metadata: {
 				source: "arc-notifications",
 				eventId: event.meta.id,
+				...organizationId !== void 0 ? { organizationId } : {},
 				/**
 				* The NOTIFICATION OCCURRENCE — `baseKey` BEFORE the per-recipient suffix.
 				*
@@ -925,9 +994,17 @@ function toEntry(doc) {
 		status: doc.status,
 		duration: doc.duration ?? 0,
 		...doc.metadata ? { metadata: doc.metadata } : {},
-		...doc.subject ? { subject: { ...doc.subject } } : {}
+		...doc.subject ? { subject: { ...doc.subject } } : {},
+		...doc.organizationId ? { organizationId: doc.organizationId } : {}
 	};
 }
+/** The payload's organization: its own metadata first, then the recipient's resolver stamp. */
+function organizationOf(payload) {
+	const fromPayload = payload.metadata?.organizationId;
+	if (typeof fromPayload === "string" && fromPayload !== "") return fromPayload;
+	const fromRecipient = payload.recipient.metadata?.organizationId;
+	return typeof fromRecipient === "string" && fromRecipient !== "" ? fromRecipient : null;
+}
 function createRepositoryDeliveryLog(repository, options = {}) {
 	const { defaultLimit = 100 } = options;
 	return {
@@ -942,7 +1019,8 @@ function createRepositoryDeliveryLog(repository, options = {}) {
 				status: deriveStatus(dispatch),
 				duration: dispatch.duration,
 				...payload.metadata ? { metadata: payload.metadata } : {},
-				...payload.subject ? { subject: payload.subject } : {}
+				...payload.subject ? { subject: payload.subject } : {},
+				organizationId: organizationOf(payload)
 			};
 			await repository.create(doc);
 		},
@@ -1154,6 +1232,33 @@ function templatesResource(options) {
 //#endregion
 //#region src/triggerAdapter.ts
 /**
+* Trigger registry → `notifyOn` config.
+*
+* The host writes a flat, readable registry of `NotificationTrigger`s (what
+* fires, who gets it, what it says). The module wants `NotifyTrigger`s
+* (channels, audience resolver, data resolver, in-app block). This is the
+* conversion, and it is identical in every host — only the registry DATA differs.
+*
+* Moved here from `@spinekit/core/notifications` (2026-08-14) so it returns the
+* REAL `NotifyTrigger` instead of a hand-maintained structural mirror.
+*
+* ## What is BAKED IN
+*   - customer-audience triggers get NO in-app channel. Buyers are not dashboard
+*     users; a feed row for them is a row nobody can ever read.
+*   - a trigger's `channels` list appends those channels unconditionally.
+*     Hub-backed channels no-op when no provider is connected, so naming a
+*     channel is always safe — the provider's presence IS the gate. Channel
+*     names are OPEN: this package never enumerates the product's connectors.
+*   - `extract` returning `null` yields a `null` audience, which the module
+*     treats as "skip". This is how a trigger filters a broad event.
+*   - a customer trigger whose `extract` returns no `recipient` also skips,
+*     rather than dispatching to nobody.
+*
+* ## What stays HOST
+*   - the registry itself (business copy, roles, which events matter)
+*   - any entity kinds beyond the defaults, via `entityIdVars`
+*/
+/**
 * `entityType` → the `extract` variable holding that entity's id.
 *
 * The in-app row wants an `entityId` for deep-linking and badge grouping, but
@@ -1349,7 +1454,29 @@ function toGatedNotifyTriggers(t, options, overrides) {
 		channels: declaredChannels(t),
 		title: t.template.title,
 		message: t.template.message,
-		...t.priority ? { priority: t.priority } : {}
+		...t.priority ? { priority: t.priority } : {},
+		...t.sourceChannels ? { sourceChannels: t.sourceChannels } : {}
+	};
+	/**
+	* The effective settings resolve ONCE per event per trigger, shared by every
+	* channel expansion below, memoised on the work scope arc enters per
+	* dispatch. The slot is per TRIGGER (a fresh symbol per call), so two
+	* triggers on one event never share a resolution even when they share a
+	* type. Outside a scope there is nothing to share — one read per expansion,
+	* slower, never wrong.
+	*/
+	const slot = Symbol("arc-notifications.effectiveSettings");
+	const effectiveFor = (organizationId) => {
+		const load = async () => resolveEffectiveSettings(type, organizationId, await overrides.store.forOrganization(organizationId), defaults);
+		const memo = scopedValue(slot, () => /* @__PURE__ */ new Map());
+		if (!memo) return load();
+		const key = organizationId ?? "__company__";
+		const pending = memo.get(key);
+		if (pending) return pending;
+		const created = load();
+		memo.set(key, created);
+		created.catch(() => memo.delete(key));
+		return created;
 	};
 	return candidateChannels(t, options.catalog).map((channel) => ({
 		...base,
@@ -1357,8 +1484,7 @@ function toGatedNotifyTriggers(t, options, overrides) {
 		audience: async (e) => {
 			const ex = t.extract(e.payload ?? {});
 			if (!ex) return null;
-			const rows = await overrides.store.forOrganization(ex.organizationId ?? null);
-			const eff = resolveEffectiveSettings(type, ex.organizationId ?? null, rows, defaults);
+			const eff = await effectiveFor(ex.organizationId ?? null);
 			/**
 			* Report a skip so it is COUNTABLE, then skip.
 			*
@@ -1404,10 +1530,20 @@ function toGatedNotifyTriggers(t, options, overrides) {
 					organizationId: ex.organizationId
 				};
 			}
-			if (eff.recipients.length === 0) return skip("no_recipients");
+			/**
+			* An operator who cleared the list means nobody — skip rather than
+			* dispatching to an empty audience the resolver would widen.
+			*
+			* Literal addresses count as an audience. Someone who wants order mail at
+			* `ops@` and nowhere else clears the roles and types the address; treating
+			* that as "no recipients" would silence exactly the configuration they
+			* just built, and report it as their own doing.
+			*/
+			if (eff.recipients.length === 0 && eff.recipientEmails.length === 0) return skip("no_recipients");
 			return {
 				roles: eff.recipients,
 				organizationId: ex.organizationId,
+				...eff.recipientEmails.length > 0 ? { recipientEmails: eff.recipientEmails } : {},
 				...ex.triggeredBy ? { excludeUserId: ex.triggeredBy } : {}
 			};
 		}
@@ -1455,4 +1591,4 @@ function getRecipientMatrix(triggers) {
 	return matrix;
 }
 //#endregion
-export { DEFAULT_ENTITY_ID_VARS, INAPP_DATA_KEY, IN_APP_CHANNEL, InAppChannel, SseChannel, createCachedTriggerOverrideStore, createDbFirstResolver, createInAppBackfill, createNotificationChannelCatalog, createRepositoryDeliveryLog, createUnreadCountCache, dispatchTrigger, evaluateSourceChannel, getRecipientMatrix, getRegisteredEvents, getTriggerByEvent, getTriggersByEvent, inAppFeedResource, notificationsJob, notificationsModule, readInAppContent, renderInApp, resolveEffectiveSettings, templatesResource, toNotifyTrigger, toNotifyTriggers };
+export { DEFAULT_ENTITY_ID_VARS, INAPP_DATA_KEY, IN_APP_CHANNEL, InAppChannel, SseChannel, createCachedTriggerOverrideStore, createDbFirstResolver, createInAppBackfill, createNotificationChannelCatalog, createRepositoryDeliveryLog, createUnreadCountCache, dispatchTrigger, evaluateSourceChannel, getRecipientMatrix, getRegisteredEvents, getTriggerByEvent, getTriggersByEvent, inAppFeedResource, notificationsJob, notificationsModule, notifyTriggerHandlers, readInAppContent, renderInApp, resolveEffectiveSettings, templatesResource, toNotifyTrigger, toNotifyTriggers };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/arc-notifications",
-  "version": "0.6.3",
+  "version": "0.9.0",
   "description": "Notifications module for @classytic/arc — domain events → multi-channel notifications via @classytic/notifications, with DB-draftable templates, repo-backed delivery log, and a templates resource",
   "type": "module",
   "exports": {
@@ -29,10 +29,10 @@
     "prepublishOnly": "node ../../scripts/prepublish-gate.mjs"
   },
   "peerDependencies": {
-    "@classytic/arc": ">=2.38.0",
-    "@classytic/notifications": ">=2.5.0",
-    "@classytic/primitives": ">=0.26.4",
-    "@classytic/repo-core": ">=0.26.0"
+    "@classytic/arc": ">=2.43.0",
+    "@classytic/notifications": ">=2.6.0",
+    "@classytic/primitives": ">=0.31.0",
+    "@classytic/repo-core": ">=0.31.0"
   },
   "keywords": [
     "arc",