@classytic/arc-notifications 0.2.0 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Classytic LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -197,3 +197,7 @@ direct queue dependency.
 
 Generalized from be-prod's production `shared/notifications` (db-first resolver) +
 `resources/notifications` (email-template model, admin resource, event-trigger registry).
+
+## Trademark
+
+MIT-licensed code. "Classytic"/"arc" names + logos are trademarks of Classytic LLC — see [TRADEMARK.md](TRADEMARK.md).

package/dist/index.d.mts

@@ -5,7 +5,6 @@ import { PermissionCheck } from "@classytic/arc/permissions";
 import { FastifyInstance, FastifyRequest } from "fastify";
 import { DomainEvent } from "@classytic/primitives/events";
 import { RepositoryLike } from "@classytic/repo-core/adapter";
-
 //#region src/inApp.d.ts
 /**
  * In-app notification content — the shared seam between a `notifyOn` trigger's
@@ -131,6 +130,23 @@ interface InAppFeedRepository<TRow = unknown> {
    * `DELETE /:id`. Hard vs soft delete is the host's call.
    */
   delete?(organizationId: string, userId: string, id: string): Promise<boolean>;
+  /**
+   * OPTIONAL — delete every ALREADY-READ row for this user; returns the count.
+   * When implemented, the feed resource registers `DELETE /read`.
+   *
+   * Read-only by design, and that is the whole safety property: an unread row
+   * is one the user has not seen, so a "clear" that removed it would destroy
+   * the notification instead of dismissing it — silently, since nothing can
+   * report a message nobody read. Odoo's garbage collector draws the same line
+   * (it vacuums SENT notifications and keeps failures), and per-row `delete`
+   * remains available for deliberately discarding something unread.
+   *
+   * This exists because `markAllRead` is not a clear: it greys the list and
+   * leaves every row in place, so an operator who wants an empty inbox has no
+   * verb at all — the state they are asking for is unreachable one row at a
+   * time.
+   */
+  deleteRead?(organizationId: string, userId: string): Promise<number>;
 }
 /**
  * Cache seam for the unread badge count — the hottest query in the system
@@ -278,9 +294,9 @@ interface InAppChannelConfig extends ChannelConfig {
 }
 declare class InAppChannel extends BaseChannel<InAppChannelConfig> {
   private readonly repository;
-  private readonly port?;
+  private readonly port;
   private readonly eventName;
-  private readonly unreadCache?;
+  private readonly unreadCache;
   constructor(config: InAppChannelConfig);
   /** Skip (not fail) when this payload isn't an in-app notification. */
   canSend(payload: NotificationPayload): SendResult | null;
@@ -364,6 +380,24 @@ interface NotifyTrigger<TPayload = unknown> {
   readonly priority?: InAppPriority;
   /** Template variables. Default: the event payload (when object-shaped). */
   readonly data?: (event: DomainEvent<TPayload>) => Record<string, unknown> | Promise<Record<string, unknown>>;
+  /**
+   * The BUSINESS DOCUMENT this trigger's notifications are about, extracted
+   * from the event — `{ sourceModel, sourceId }`.
+   *
+   * Belongs HERE, beside `recipient` and `data`, for the same reason they do:
+   * the notification control centre splits ownership so that CODE owns the
+   * event and its extraction while the DATABASE owns channels and recipients.
+   * Which document an event concerns is a fact about the event's shape, so it
+   * is code — an operator cannot configure it and must never have to.
+   *
+   * Omit for events that concern no single document (a segment broadcast). A
+   * fabricated subject is worse than none: it makes a document's send history
+   * show messages that were never about it.
+   */
+  readonly subject?: (event: DomainEvent<TPayload>) => {
+    sourceModel: string;
+    sourceId: string;
+  } | undefined;
   /**
    * Dedup key for at-least-once transports. Default:
    * `meta.idempotencyKey ?? "<type>:<meta.id>"`, suffixed per recipient on
@@ -373,12 +407,24 @@ interface NotifyTrigger<TPayload = unknown> {
   /** Compose-time kill switch (env-gated triggers). Default true. */
   readonly enabled?: boolean;
 }
-interface NotificationsModuleConfig extends Omit<NotificationServiceConfig, "queue"> {
+interface NotificationsModuleConfig extends Omit<NotificationServiceConfig, "queue" | "channels"> {
+  /**
+   * The channels to dispatch through — a value, or a FUNCTION resolved at bootstrap.
+   *
+   * The function form exists for the same reason `queue`'s does: a channel can be expensive to
+   * build. A host wiring a provider-backed channel has to construct a hub, a credential vault and
+   * a repository to do it, and passing the built array means all of that runs while the module
+   * GRAPH is being composed — before arc has validated it, for a module the deployment may still
+   * reject. In be-prod that registered a mongoose model and derived an AES key at composition.
+   *
+   * Resolved inside `bootstrap`, where the service is constructed anyway, so nothing else moves.
+   */
+  readonly channels?: NotificationServiceConfig["channels"] | ((fastify: FastifyInstance) => NotificationServiceConfig["channels"] | Promise<NotificationServiceConfig["channels"]>);
   /** Module name (registry + export-map key). Default "notifications". */
   readonly name?: string;
   /** Bring-your-own service — skips construction; service config fields ignored. */
   readonly service?: NotificationService;
-  /** Declarative event → notification triggers, wired in `afterResources`. */
+  /** Declarative event → notification triggers, contributed as `eventHandlers`. */
   readonly notifyOn?: readonly NotifyTrigger[];
   /**
    * Resolves a trigger's `audience` selector to recipients (the shared
@@ -423,6 +469,15 @@ interface DeliveryLogDoc {
   readonly status: EntryStatus;
   readonly duration: number;
   readonly metadata?: Record<string, unknown>;
+  /**
+   * The business document this delivery concerned. A STORE MUST INDEX IT —
+   * this field exists precisely so "every message about invoice X" is a keyed
+   * read rather than a scan of the unindexed `metadata` blob.
+   */
+  readonly subject?: {
+    readonly sourceModel: string;
+    readonly sourceId: string;
+  };
 }
 interface RepositoryDeliveryLogOptions {
   /** Cap for `query()` when the caller gives no limit. Default 100. */
@@ -475,4 +530,353 @@ interface TemplatesResourceOptions {
 }
 declare function templatesResource(options: TemplatesResourceOptions): import("@classytic/arc").ResourceDefinition<unknown>;
 //#endregion
-export { type CodeTemplates, type CreateUnreadCountCacheOptions, type DbFirstResolverOptions, type DbFirstTemplateResolver, type DeliveryLogDoc, INAPP_DATA_KEY, 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 NotificationsJob, type NotificationsJobOptions, type NotificationsModuleConfig, type NotifyTrigger, type RealtimePushPort, type RecipientResolver, type RepositoryDeliveryLogOptions, SseChannel, type SseChannelConfig, type StoredTemplate, type TemplateStore, type TemplatesResourceOptions, type UnreadCountCache, createDbFirstResolver, createInAppBackfill, createRepositoryDeliveryLog, createUnreadCountCache, dispatchTrigger, inAppFeedResource, notificationsJob, notificationsModule, readInAppContent, renderInApp, templatesResource };
+//#region src/triggerAuthoring.d.ts
+/**
+ * Notification trigger contract — the readable DSL a host writes its registry in.
+ *
+ * This module owns the MECHANISM (subscription, dispatch, channel fan-out) and its
+ * `NotifyTrigger` is the shape the dispatcher consumes. That shape is
+ * dispatch-oriented: audience resolvers, data extractors, channel arrays. Writing
+ * forty of them by hand is how a registry stops being readable.
+ *
+ * `NotificationTrigger` is the AUTHORING shape — one flat entry per notification,
+ * saying what fires, who gets it, and what it says. `toNotifyTriggers` in
+ * `./triggerAdapter.js` converts one to the other.
+ *
+ * Moved here from `@spinekit/core/notifications` (2026-08-14): the previous home
+ * declared a structural mirror of `NotifyTrigger` to avoid depending on this
+ * package — a re-declared provider type, and once narrower than its subject
+ * (sync-only `audience`), which silently foreclosed valid implementations. Living
+ * beside the owner, the mirror is unnecessary and the compiler checks the real seam.
+ */
+/** Who a trigger targets. */
+type NotificationAudienceType = "staff" | "customer";
+/** Direct contact for a customer-facing notification. */
+interface NotificationRecipientContact {
+  email?: string;
+  phone?: string;
+  name?: string;
+}
+/** What `extract` returns: the scope, the template variables, and the target. */
+interface NotificationExtractResult {
+  organizationId: string;
+  variables: Record<string, string>;
+  triggeredBy?: string;
+  /** Direct contact for `audienceType: 'customer'`. */
+  recipient?: NotificationRecipientContact;
+}
+/**
+ * One notification, declared.
+ *
+ * Adding a notification is adding one of these to the host's registry — nothing
+ * else to touch.
+ */
+interface NotificationTrigger {
+  /** Arc event name to subscribe to (e.g. `'order:created'`). */
+  event: string;
+  /**
+   * Notification kind — the feed type AND the email template id. Defaults to
+   * the event name.
+   *
+   * Two triggers MAY share an event (an informational alert plus an escalation);
+   * distinct `type` values are what keep them independently filterable.
+   */
+  type?: string;
+  /** In-app template. `{variable}` placeholders resolve against `extract`'s variables. */
+  template: {
+    title: string;
+    message: string;
+    /** Frontend route, with `{variable}` placeholders. */
+    link?: string;
+    /** Entity kind, for badge/icon grouping and entity-id derivation. */
+    entityType?: string;
+  };
+  /**
+   * Roles that receive this notification. `'*'` = all branch members.
+   * Ignored when `audienceType` is `'customer'` — that target comes from
+   * `extract`'s `recipient`.
+   */
+  recipients: string[];
+  /**
+   * `'staff'` (default) resolves branch members by `recipients` roles.
+   * `'customer'` targets the direct contact `extract` returns, with NO staff
+   * lookup and NO in-app feed row (buyers are not dashboard users).
+   */
+  audienceType?: NotificationAudienceType;
+  priority?: "low" | "normal" | "high";
+  /** Fan out to the connected email provider. */
+  sendEmail?: boolean;
+  /** Fan out to the connected WhatsApp provider. */
+  sendWhatsapp?: boolean;
+  /** Fan out to the connected SMS provider. */
+  sendSms?: boolean;
+  /**
+   * Pull dispatch variables out of the event payload.
+   *
+   * Returning `null` SKIPS the notification — this is the filter seam. A
+   * trigger that subscribes to a broad event (`order:payment.state_updated`)
+   * and only wants one case (`chargeStatus === 'failed'`) expresses that here,
+   * rather than notifying on every state change.
+   */
+  extract: (payload: Record<string, any>) => NotificationExtractResult | null;
+}
+//#endregion
+//#region src/triggerOverride.d.ts
+/**
+ * Notification trigger OVERRIDES — the admin-editable half of the registry.
+ *
+ * ## The split, and why it is not "make triggers DB rows"
+ *
+ * A `NotificationTrigger` carries two very different kinds of thing:
+ *
+ * | stays CODE | becomes DATA |
+ * |---|---|
+ * | `event` — what to subscribe to | `enabled` — does this fire here at all |
+ * | `extract` — a typed function: filters the event and pulls variables | `recipients` — which roles get told |
+ * | | `channels` — in-app / email / whatsapp / sms |
+ * | | `template` — the copy an operator wants to reword |
+ *
+ * `extract` is the reason the whole registry cannot become rows. It decides
+ * whether a broad event is even relevant (`chargeStatus === 'failed'`) and maps
+ * a payload to variables — expressing that as data means shipping an evaluator,
+ * which is a code-execution surface in the notification path. Odoo draws the
+ * same line: `base.automation` rows hold the trigger and the filter, while the
+ * action BODY is Python in `ir.actions.server`.
+ *
+ * So the code registry is the CATALOG (what this deployment is capable of
+ * announcing) and these rows are the CONFIGURATION (what a given scope has
+ * actually turned on, to whom, over which channel).
+ *
+ * ## Scoped per ORGANIZATION, with an app-wide fallback
+ *
+ * `organizationId: null` is the app-wide default; a row with an organization id
+ * overrides it for that scope only. Absence of a row means "use the code
+ * default" — a fresh deployment behaves exactly as its registry declares, and
+ * turning the feature on requires an operator to actually decide something.
+ *
+ * ## Kit-less by design
+ *
+ * This package carries NO database dependency (see `repositoryDeliveryLog` /
+ * `templatesResource` — the same posture). This file owns the ROW SHAPE, the
+ * store PORT, the TTL-cached store wrapper over a load port, and the effective-
+ * settings RESOLUTION. The persistence binding (a mongoose model and its
+ * indexes, in the product layer) supplies `load`.
+ */
+/** The channels a trigger can be routed to. `in-app` is the dashboard feed. */
+declare const NOTIFICATION_CHANNELS: readonly ["in-app", "email", "whatsapp", "sms"];
+type NotificationChannel = (typeof NOTIFICATION_CHANNELS)[number];
+interface NotificationTriggerOverrideDoc {
+  /**
+   * The trigger's `type` (falling back to its `event`) — the same key
+   * `toNotifyTrigger` uses as the template id, so a row is addressable by the
+   * identifier an admin already sees in the catalog.
+   */
+  triggerType: string;
+  /** `null` = app-wide default; an organization id overrides it for that scope. */
+  organizationId?: string | null;
+  /** `false` silences the trigger entirely for this scope. */
+  enabled?: boolean;
+  /** Replaces the code trigger's roles. Empty array = nobody (use `enabled` to silence). */
+  recipients?: string[] | null;
+  /** Replaces the code trigger's channel set. */
+  channels?: NotificationChannel[] | null;
+  /** Copy overrides. Unset fields fall back to the code template. */
+  title?: string | null;
+  message?: string | null;
+  priority?: "low" | "normal" | "high" | null;
+  updatedBy?: string | null;
+}
+/** The reader the resolver needs. Structural, so a host can pass a cache or a fake. */
+interface TriggerOverrideStore {
+  /**
+   * Every override that could apply to `organizationId` — its scope rows AND
+   * the app-wide (`null`) rows. Returning both in one read is deliberate:
+   * resolving a fallback with a second query per event would put a round trip on
+   * the notification path.
+   */
+  forOrganization(organizationId: string | null): Promise<NotificationTriggerOverrideDoc[]>;
+}
+/**
+ * The persistence PORT the cached store wraps — "give me every row that could
+ * apply to this scope" (its own rows and the `null` app-wide rows, one read).
+ */
+type TriggerOverrideLoader = (organizationId: string | null) => Promise<NotificationTriggerOverrideDoc[]>;
+interface CreateCachedTriggerOverrideStoreOptions {
+  /**
+   * Cache TTL in ms. Default 30s.
+   *
+   * These rows change when an admin edits a form — rarely — but they are read on
+   * EVERY notifiable event, so an uncached store puts a query in front of every
+   * order. 30s bounds how long a change takes to take effect without making the
+   * hot path pay for a lookup that almost never differs.
+   */
+  ttlMs?: number;
+}
+/**
+ * TTL-cached {@link TriggerOverrideStore} over a load port.
+ *
+ * `invalidate()` exists for the write path: the admin resource calls it after
+ * any mutation so an operator's change applies within one save rather than one
+ * TTL window.
+ */
+declare function createCachedTriggerOverrideStore(load: TriggerOverrideLoader, options?: CreateCachedTriggerOverrideStoreOptions): TriggerOverrideStore & {
+  invalidate: () => void;
+};
+/**
+ * The EFFECTIVE settings for one trigger in one scope.
+ *
+ * Precedence is scope → app-wide → code default, and each FIELD resolves
+ * independently: a scope that only overrode `channels` still inherits the
+ * app-wide `recipients`. Whole-row precedence would force an admin to restate
+ * every field to change one, and restating is how two settings silently drift.
+ */
+interface EffectiveTriggerSettings {
+  enabled: boolean;
+  recipients: string[];
+  channels: NotificationChannel[];
+  title: string;
+  message: string;
+  priority?: "low" | "normal" | "high" | undefined;
+}
+interface CodeTriggerDefaults {
+  recipients: string[];
+  channels: NotificationChannel[];
+  title: string;
+  message: string;
+  priority?: "low" | "normal" | "high" | undefined;
+}
+declare function resolveEffectiveSettings(triggerType: string, organizationId: string | null, rows: readonly NotificationTriggerOverrideDoc[], defaults: CodeTriggerDefaults): EffectiveTriggerSettings;
+//#endregion
+//#region src/triggerAdapter.d.ts
+/**
+ * `entityType` → the `extract` variable holding that entity's id.
+ *
+ * The in-app row wants an `entityId` for deep-linking and badge grouping, but
+ * the variable it lives under is named per entity. This is the default
+ * commerce mapping; a host with its own entity kinds passes `entityIdVars`.
+ */
+declare const DEFAULT_ENTITY_ID_VARS: Record<string, string>;
+interface TriggerAdapterOptions {
+  /**
+   * Extra `entityType` → id-variable mappings, merged over the defaults.
+   *
+   * An unmapped `entityType` simply yields no `entityId` — the notification
+   * still delivers, it just has nothing to deep-link to.
+   */
+  entityIdVars?: Record<string, string>;
+  /**
+   * ADMIN OVERRIDES — when supplied, each trigger expands into one module
+   * trigger PER CHANNEL, and every one is gated on the stored settings for the
+   * event's organization.
+   *
+   * ## Why expansion rather than one trigger with dynamic channels
+   *
+   * `NotifyTrigger.channels` is a STATIC `readonly string[]` — arc resolves it
+   * at registration, not per dispatch. So "this scope wants order alerts on
+   * WhatsApp but not email" cannot be expressed by mutating one trigger's
+   * channel list at send time. It CAN be expressed as separate triggers, each
+   * restricted to one channel, each skipping when that channel is off for the
+   * scope — `audience` IS a per-event async function, which is the seam that
+   * makes this possible without changing arc.
+   *
+   * The cost is N subscriptions per trigger instead of one, and `extract` runs
+   * per channel. `extract` is pure and cheap by contract (the adapter already
+   * calls it twice per dispatch), so this trades a little fan-out for a control
+   * an operator can actually use.
+   *
+   * OMITTED = unchanged behaviour: one trigger, static channels from the
+   * `sendEmail`/`sendWhatsapp`/`sendSms` flags. Every existing host keeps its
+   * exact current dispatch until it opts in.
+   */
+  overrides?: TriggerOverrideResolution;
+}
+/**
+ * How the adapter reaches stored settings for the organization on an event.
+ *
+ * Just the store. The ORGANIZATION comes from the trigger's own `extract`
+ * (`ex.organizationId`) rather than a second resolver here — `extract` is
+ * already the one place that knows how a given event carries its scope, and a
+ * parallel answer would be a second place to get it wrong.
+ */
+interface TriggerOverrideResolution {
+  store: TriggerOverrideStore;
+}
+/**
+ * Adapt one authoring trigger to one module trigger.
+ *
+ * Note `extract` is invoked separately by `audience` and by `data`. The module
+ * calls both per dispatch, so an `extract` with side effects would run them
+ * twice — keep extractors pure (every one in practice is a payload reshape).
+ */
+declare function toNotifyTrigger(t: NotificationTrigger, options?: TriggerAdapterOptions): NotifyTrigger;
+/**
+ * Adapt a whole registry — what a host assigns to the module's `notifyOn`.
+ *
+ * With `options.overrides`, each trigger becomes one entry per channel, gated on
+ * the admin's stored settings. Without it, the mapping is 1:1 and unchanged.
+ */
+declare function toNotifyTriggers(triggers: readonly NotificationTrigger[], options?: TriggerAdapterOptions): NotifyTrigger[];
+/**
+ * First trigger registered for an event.
+ *
+ * CAVEAT: an event may carry more than one trigger (an informational alert and
+ * an escalation to a different role set both listen to `stock:low`). This
+ * returns only the first. For anything that must see all of them — a docs page,
+ * an admin matrix, a dispatch count — use `getTriggersByEvent`.
+ */
+declare function getTriggerByEvent(triggers: readonly NotificationTrigger[], event: string): NotificationTrigger | undefined;
+/** Every trigger registered for an event, in registration order. */
+declare function getTriggersByEvent(triggers: readonly NotificationTrigger[], event: string): NotificationTrigger[];
+/** Distinct event names the registry subscribes to (for docs / admin UI). */
+declare function getRegisteredEvents(triggers: readonly NotificationTrigger[]): string[];
+/**
+ * Notification kind → recipient roles (for the admin UI).
+ *
+ * Keyed by `type ?? event`, so two triggers sharing an event stay distinct
+ * rows — which is exactly why they carry different `type`s.
+ */
+declare function getRecipientMatrix(triggers: readonly NotificationTrigger[]): Record<string, string[]>;
+//#endregion
+//#region src/triggerCatalog.d.ts
+/**
+ * One trigger as an operator sees it, with the CODE defaults an override replaces.
+ *
+ * Deliberately not the internal trigger shape: `extract` is a function and cannot
+ * cross the wire, and a UI has no use for it. What a settings screen needs is the
+ * identity, a human label, and the defaults so it can show "customised" against
+ * "default" without guessing.
+ */
+interface TriggerCatalogEntry {
+  /**
+   * The override key — a trigger's `type`, falling back to its `event`.
+   *
+   * This is the same identifier `toNotifyTrigger` uses as the template id, so a row
+   * created from this screen addresses the trigger the dispatch path will look up. A
+   * settings UI keyed on anything else would write rows nothing reads.
+   */
+  triggerType: string;
+  /** The domain event it listens to, shown so an operator can trace cause to effect. */
+  event: string;
+  /** Human label. Falls back to `triggerType` when the host supplies none. */
+  label: string;
+  /** Optional grouping for the UI ("Orders", "Inventory"). */
+  group?: string;
+  /** Code-default recipient roles, replaced by an override's `recipients`. */
+  defaultRecipients: string[];
+  /** Code-default channels, replaced by an override's `channels`. */
+  defaultChannels: NotificationChannel[];
+  /** Code-default copy, overridable per scope. */
+  defaultTitle?: string;
+  defaultMessage?: string;
+}
+/**
+ * Host-supplied catalog reader.
+ *
+ * Optional on the resource: a deployment that does not expose its catalog simply has
+ * no `/catalog` route, and the settings screen says so rather than showing an empty
+ * matrix. Never defaulted to `() => []` — that would turn "not exposed" into "nothing
+ * exists", which is the silent-empty failure this file exists to avoid.
+ */
+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, 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, NOTIFICATION_CHANNELS, type NotificationAudienceType, type NotificationChannel, type NotificationExtractResult, type NotificationRecipientContact, 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, createRepositoryDeliveryLog, createUnreadCountCache, dispatchTrigger, getRecipientMatrix, getRegisteredEvents, getTriggerByEvent, getTriggersByEvent, inAppFeedResource, notificationsJob, notificationsModule, readInAppContent, renderInApp, resolveEffectiveSettings, templatesResource, toNotifyTrigger, toNotifyTriggers };

package/dist/index.mjs

@@ -2,7 +2,6 @@ import { BaseChannel, NotificationService, createSimpleResolver } from "@classyt
 import { defineResource } from "@classytic/arc";
 import { NotFoundError } from "@classytic/arc/utils";
 import { defineJob } from "@classytic/arc/integrations/jobs";
-import { subscribeWithBoundary } from "@classytic/arc/events";
 import { defineModule } from "@classytic/arc/factory";
 //#region src/backfill.ts
 function createInAppBackfill(options) {
@@ -251,7 +250,7 @@ var InAppChannel = class extends BaseChannel {
 function createUnreadCountCache(options = {}) {
 	const { ttlMs = 3e4, maxEntries = 1e4 } = options;
 	const entries = /* @__PURE__ */ new Map();
-	const keyOf = (organizationId, userId) => `${organizationId}${userId}`;
+	const keyOf = (organizationId, userId) => `${organizationId}\u0000${userId}`;
 	return {
 		get(organizationId, userId) {
 			const key = keyOf(organizationId, userId);
@@ -303,7 +302,6 @@ function inAppFeedResource(options) {
 				method: "GET",
 				path: "/",
 				permissions,
-				raw: true,
 				summary: "List my notifications (newest first, paginated)",
 				schema: { querystring: {
 					type: "object",
@@ -325,7 +323,7 @@ function inAppFeedResource(options) {
 					},
 					additionalProperties: true
 				} },
-				handler: async (req, reply) => {
+				rawHandler: async (req, reply) => {
 					const { userId, organizationId } = resolveScope(req);
 					const q = req.query ?? {};
 					const result = await repository.listForUser(organizationId, userId, {
@@ -341,9 +339,8 @@ function inAppFeedResource(options) {
 				method: "GET",
 				path: "/unread-count",
 				permissions,
-				raw: true,
 				summary: "Unread notification count (badge)",
-				handler: async (req, reply) => {
+				rawHandler: async (req, reply) => {
 					const { userId, organizationId } = resolveScope(req);
 					if (unreadCache) {
 						const cached = await unreadCache.get(organizationId, userId);
@@ -360,9 +357,8 @@ function inAppFeedResource(options) {
 				method: "PATCH",
 				path: "/:id/read",
 				permissions,
-				raw: true,
 				summary: "Mark a single notification read",
-				handler: async (req, reply) => {
+				rawHandler: async (req, reply) => {
 					const scope = resolveScope(req);
 					const id = req.params.id;
 					const updated = await repository.markRead(scope.organizationId, scope.userId, id);
@@ -375,9 +371,8 @@ function inAppFeedResource(options) {
 				method: "PATCH",
 				path: "/read-all",
 				permissions,
-				raw: true,
 				summary: "Mark all my notifications read",
-				handler: async (req, reply) => {
+				rawHandler: async (req, reply) => {
 					const scope = resolveScope(req);
 					const modifiedCount = await repository.markAllRead(scope.organizationId, scope.userId);
 					await afterReadStateChange(scope, {
@@ -387,13 +382,27 @@ function inAppFeedResource(options) {
 					return reply.send({ modifiedCount });
 				}
 			},
+			...typeof repository.deleteRead === "function" ? [{
+				method: "DELETE",
+				path: "/read",
+				permissions,
+				summary: "Delete all my already-read notifications",
+				rawHandler: async (_req, reply) => {
+					const scope = resolveScope(_req);
+					const deletedCount = await repository.deleteRead(scope.organizationId, scope.userId);
+					await afterReadStateChange(scope, {
+						deletedCount,
+						clearedRead: true
+					});
+					return reply.send({ deletedCount });
+				}
+			}] : [],
 			...typeof repository.delete === "function" ? [{
 				method: "DELETE",
 				path: "/:id",
 				permissions,
-				raw: true,
 				summary: "Delete (dismiss) a notification",
-				handler: async (req, reply) => {
+				rawHandler: async (req, reply) => {
 					const scope = resolveScope(req);
 					const id = req.params.id;
 					if (!await repository.delete(scope.organizationId, scope.userId, id)) throw new NotFoundError("Notification");
@@ -487,7 +496,7 @@ function notificationsJob(options = {}) {
 			ref.processor = processor;
 		},
 		async getJob(id) {
-			const status = await dispatcher.getStatus(id);
+			const status = await dispatcher.getStatus(name, id);
 			if (!status) return null;
 			const created = new Date(status.timestamp ?? Date.now());
 			return {
@@ -550,41 +559,45 @@ function notificationsJob(options = {}) {
 * const svc = getModuleExports<NotificationService>(app, "notifications");
 * ```
 *
-* Triggers subscribe through arc's `subscribeWithBoundary` — handler failures
-* are logged and swallowed (fire-and-forget, matching arc's event gotcha), and
+* Triggers are contributed through arc's `eventHandlers` module arm (2.24), so
+* arc owns subscription ordering AND teardown: it unsubscribes every handler at
+* shutdown BEFORE any module `onClose` runs, while the service and its queue
+* are still alive. A hand-rolled `afterResources` subscribe cannot promise that
+* — its own `onClose` races the modules it depends on.
+*
+* Each handler declares `boundary: true`, so arc contains failures — logged and
+* swallowed (fire-and-forget, matching arc's event gotcha), because a template
+* or channel failure must not block the transport ack and DLQ the event. And
 * `idempotencyKey` defaults from event identity because Redis Streams are
 * at-least-once: redelivery must not double-send.
 */
 function notificationsModule(config) {
-	const { name = "notifications", service: provided, notifyOn = [], decorate = "notifications", queue, recipientResolver, ...serviceConfig } = config;
+	const { name = "notifications", service: provided, notifyOn = [], decorate = "notifications", queue, recipientResolver, channels, ...serviceConfig } = config;
 	let service;
-	const unsubscribes = [];
 	return defineModule({
 		name,
-		bootstrap(fastify) {
+		async bootstrap(fastify) {
 			const resolvedQueue = typeof queue === "function" ? queue(fastify) : queue;
+			const resolvedChannels = typeof channels === "function" ? await channels(fastify) : channels;
 			service = provided ?? new NotificationService({
 				...serviceConfig,
+				...resolvedChannels ? { channels: resolvedChannels } : {},
 				...resolvedQueue ? { queue: resolvedQueue } : {}
 			});
 			if (!resolvedQueue && !provided && notifyOn.some((t) => t.enabled !== false)) fastify.log.warn(`[arc-notifications] module "${name}" wires notifyOn trigger(s) with NO durable queue — sends run on the in-memory queue and are lost on restart / not shared across instances. Wire \`queue: (f) => notificationsJob(...).toQueueAdapter(f.jobs)\` (with arc's jobsPlugin) for durability.`);
 			if (decorate !== false && !(decorate in fastify)) fastify.decorate(decorate, service);
 			return service;
 		},
-		async afterResources(fastify) {
+		eventHandlers: (fastify) => {
 			const triggers = notifyOn.filter((t) => t.enabled !== false);
-			if (triggers.length === 0) return;
-			const bus = fastify;
-			if (!bus.events) throw new Error(`[arc-notifications] module "${name}" declares ${triggers.length} notifyOn trigger(s) but \`fastify.events\` is not decorated — register arc's eventPlugin (or drop notifyOn).`);
-			for (const trigger of triggers) {
-				const unsubscribe = await subscribeWithBoundary(bus, trigger.event, async (event) => dispatchTrigger(service, trigger, event, { recipientResolver }), { name: `arc-notifications:${trigger.event}` });
-				unsubscribes.push(unsubscribe);
-			}
+			if (triggers.length === 0) return [];
 			fastify.log.debug(`[arc-notifications] ${triggers.length} trigger(s) subscribed`);
-		},
-		async onClose() {
-			for (const unsubscribe of unsubscribes) unsubscribe();
-			unsubscribes.length = 0;
+			return triggers.map((trigger, index) => ({
+				name: `${name}:${trigger.event}#${index}`,
+				event: trigger.event,
+				boundary: true,
+				handler: async (event) => dispatchTrigger(service, trigger, event, { ...recipientResolver ? { recipientResolver } : {} })
+			}));
 		}
 	});
 }
@@ -609,6 +622,7 @@ async function dispatchTrigger(service, trigger, event, opts) {
 	const baseKey = trigger.idempotencyKey ? trigger.idempotencyKey(event) : event.meta.idempotencyKey ?? `${event.type}:${event.meta.id}`;
 	for (const [index, recipient] of recipients.entries()) {
 		const idempotencyKey = baseKey === void 0 ? void 0 : recipients.length === 1 ? baseKey : `${baseKey}:${recipient.id ?? recipient.email ?? index}`;
+		const subject = trigger.subject?.(event);
 		await service.send({
 			event: event.type,
 			template: trigger.template ?? event.type,
@@ -616,6 +630,7 @@ async function dispatchTrigger(service, trigger, event, opts) {
 			data: sendData,
 			...trigger.channels ? { channels: [...trigger.channels] } : {},
 			...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+			...subject ? { subject } : {},
 			metadata: {
 				source: "arc-notifications",
 				eventId: event.meta.id
@@ -642,7 +657,8 @@ function toEntry(doc) {
 		results: doc.results ?? [],
 		status: doc.status,
 		duration: doc.duration ?? 0,
-		...doc.metadata ? { metadata: doc.metadata } : {}
+		...doc.metadata ? { metadata: doc.metadata } : {},
+		...doc.subject ? { subject: { ...doc.subject } } : {}
 	};
 }
 function createRepositoryDeliveryLog(repository, options = {}) {
@@ -658,7 +674,8 @@ function createRepositoryDeliveryLog(repository, options = {}) {
 				results: dispatch.results,
 				status: deriveStatus(dispatch),
 				duration: dispatch.duration,
-				...payload.metadata ? { metadata: payload.metadata } : {}
+				...payload.metadata ? { metadata: payload.metadata } : {},
+				...payload.subject ? { subject: payload.subject } : {}
 			};
 			await repository.create(doc);
 		},
@@ -668,6 +685,21 @@ function createRepositoryDeliveryLog(repository, options = {}) {
 			if (filter.recipientEmail) equality.recipientEmail = filter.recipientEmail;
 			if (filter.event) equality.event = filter.event;
 			if (filter.status) equality.status = filter.status;
+			/**
+			* Pushed into the EQUALITY filter, not the in-memory pass below.
+			*
+			* The post-fetch filters (`after`/`before`/`channel`) narrow a page that
+			* was already limited — acceptable for a range or an array membership.
+			* Subject is different: it is the primary way a document screen reads its
+			* own history, so filtering it in memory would fetch `limit` rows of
+			* OTHER documents' deliveries and return however few happened to match —
+			* an empty send history for an invoice that was definitely emailed.
+			* Dotted paths so the store's compound index is usable.
+			*/
+			if (filter.subject) {
+				equality["subject.sourceModel"] = filter.subject.sourceModel;
+				equality["subject.sourceId"] = filter.subject.sourceId;
+			}
 			const limit = filter.limit ?? defaultLimit;
 			const result = await repository.getAll({
 				filter: equality,
@@ -853,4 +885,287 @@ function templatesResource(options) {
 	});
 }
 //#endregion
-export { INAPP_DATA_KEY, InAppChannel, SseChannel, createDbFirstResolver, createInAppBackfill, createRepositoryDeliveryLog, createUnreadCountCache, dispatchTrigger, inAppFeedResource, notificationsJob, notificationsModule, readInAppContent, renderInApp, templatesResource };
+//#region src/triggerOverride.ts
+/**
+* Notification trigger OVERRIDES — the admin-editable half of the registry.
+*
+* ## The split, and why it is not "make triggers DB rows"
+*
+* A `NotificationTrigger` carries two very different kinds of thing:
+*
+* | stays CODE | becomes DATA |
+* |---|---|
+* | `event` — what to subscribe to | `enabled` — does this fire here at all |
+* | `extract` — a typed function: filters the event and pulls variables | `recipients` — which roles get told |
+* | | `channels` — in-app / email / whatsapp / sms |
+* | | `template` — the copy an operator wants to reword |
+*
+* `extract` is the reason the whole registry cannot become rows. It decides
+* whether a broad event is even relevant (`chargeStatus === 'failed'`) and maps
+* a payload to variables — expressing that as data means shipping an evaluator,
+* which is a code-execution surface in the notification path. Odoo draws the
+* same line: `base.automation` rows hold the trigger and the filter, while the
+* action BODY is Python in `ir.actions.server`.
+*
+* So the code registry is the CATALOG (what this deployment is capable of
+* announcing) and these rows are the CONFIGURATION (what a given scope has
+* actually turned on, to whom, over which channel).
+*
+* ## Scoped per ORGANIZATION, with an app-wide fallback
+*
+* `organizationId: null` is the app-wide default; a row with an organization id
+* overrides it for that scope only. Absence of a row means "use the code
+* default" — a fresh deployment behaves exactly as its registry declares, and
+* turning the feature on requires an operator to actually decide something.
+*
+* ## Kit-less by design
+*
+* This package carries NO database dependency (see `repositoryDeliveryLog` /
+* `templatesResource` — the same posture). This file owns the ROW SHAPE, the
+* store PORT, the TTL-cached store wrapper over a load port, and the effective-
+* settings RESOLUTION. The persistence binding (a mongoose model and its
+* indexes, in the product layer) supplies `load`.
+*/
+/** The channels a trigger can be routed to. `in-app` is the dashboard feed. */
+const NOTIFICATION_CHANNELS = [
+	"in-app",
+	"email",
+	"whatsapp",
+	"sms"
+];
+/**
+* TTL-cached {@link TriggerOverrideStore} over a load port.
+*
+* `invalidate()` exists for the write path: the admin resource calls it after
+* any mutation so an operator's change applies within one save rather than one
+* TTL window.
+*/
+function createCachedTriggerOverrideStore(load, options = {}) {
+	const ttlMs = options.ttlMs ?? 3e4;
+	const cache = /* @__PURE__ */ new Map();
+	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;
+		},
+		/** Call after a write so an admin sees their change immediately. */
+		invalidate() {
+			cache.clear();
+		}
+	};
+}
+function resolveEffectiveSettings(triggerType, organizationId, rows, defaults) {
+	const mine = rows.filter((r) => r.triggerType === triggerType);
+	const scoped = organizationId ? mine.find((r) => r.organizationId === organizationId) : void 0;
+	const appWide = mine.find((r) => r.organizationId == null);
+	/**
+	* `??` throughout, and the field it actually protects is `enabled`.
+	*
+	* An earlier version of this comment claimed `||` would swallow an EMPTY
+	* recipients array. It would not — `[]` is truthy in JS — and a falsification
+	* proved it: swapping the operator on `recipients` changed nothing. The real
+	* hazard is `enabled: false`, where `false || true` silently re-enables a
+	* trigger an operator deliberately switched off. That one IS falsifiable, and
+	* the trigger-override test fails when the operator is swapped.
+	*
+	* Recorded rather than quietly corrected: a comment asserting a guarantee the
+	* code does not have is the same defect as a guard that cannot fail, and the
+	* next reader would have "protected" the wrong line.
+	*/
+	const pick = (key) => scoped?.[key] ?? appWide?.[key] ?? void 0;
+	const enabled = pick("enabled") ?? true;
+	const recipients = pick("recipients") ?? defaults.recipients;
+	const channels = pick("channels") ?? defaults.channels;
+	const title = pick("title") ?? defaults.title;
+	const message = pick("message") ?? defaults.message;
+	const priority = pick("priority") ?? defaults.priority;
+	return {
+		enabled,
+		recipients,
+		channels,
+		title,
+		message,
+		...priority ? { priority } : {}
+	};
+}
+//#endregion
+//#region src/triggerAdapter.ts
+/**
+* `entityType` → the `extract` variable holding that entity's id.
+*
+* The in-app row wants an `entityId` for deep-linking and badge grouping, but
+* the variable it lives under is named per entity. This is the default
+* commerce mapping; a host with its own entity kinds passes `entityIdVars`.
+*/
+const DEFAULT_ENTITY_ID_VARS = {
+	order: "orderId",
+	transfer: "transferId",
+	product: "productId"
+};
+/**
+* Adapt one authoring trigger to one module trigger.
+*
+* Note `extract` is invoked separately by `audience` and by `data`. The module
+* calls both per dispatch, so an `extract` with side effects would run them
+* twice — keep extractors pure (every one in practice is a payload reshape).
+*/
+function toNotifyTrigger(t, options = {}) {
+	const type = t.type ?? t.event;
+	const entityIdVars = {
+		...DEFAULT_ENTITY_ID_VARS,
+		...options.entityIdVars
+	};
+	const entityVar = t.template.entityType ? entityIdVars[t.template.entityType] : void 0;
+	const channels = t.audienceType === "customer" ? [] : ["in-app"];
+	if (t.sendEmail) channels.push("email");
+	if (t.sendWhatsapp) channels.push("whatsapp");
+	if (t.sendSms) channels.push("sms");
+	return {
+		event: t.event,
+		template: type,
+		...t.priority ? { priority: t.priority } : {},
+		channels,
+		audience: (e) => {
+			const ex = t.extract(e.payload ?? {});
+			if (!ex) return null;
+			if (t.audienceType === "customer") {
+				if (!ex.recipient) return null;
+				return {
+					recipient: ex.recipient,
+					organizationId: ex.organizationId
+				};
+			}
+			return {
+				roles: t.recipients,
+				organizationId: ex.organizationId,
+				...ex.triggeredBy ? { excludeUserId: ex.triggeredBy } : {}
+			};
+		},
+		data: (e) => t.extract(e.payload ?? {})?.variables ?? {},
+		inApp: {
+			title: t.template.title,
+			message: t.template.message,
+			...t.template.link ? { link: t.template.link } : {},
+			...t.template.entityType ? { entityType: t.template.entityType } : {},
+			...entityVar ? { entityId: `{${entityVar}}` } : {}
+		}
+	};
+}
+/** The channel set a trigger declares in CODE — its default before any override. */
+function declaredChannels(t) {
+	const channels = t.audienceType === "customer" ? [] : ["in-app"];
+	if (t.sendEmail) channels.push("email");
+	if (t.sendWhatsapp) channels.push("whatsapp");
+	if (t.sendSms) channels.push("sms");
+	return channels;
+}
+/**
+* Every channel an override could ever turn ON for this trigger.
+*
+* The union of the declared set and the configurable ones, because a scope may
+* enable a channel the code never flagged — that is the point of the control
+* centre. A customer-audience trigger stays out of `in-app`: buyers are not
+* dashboard users, so a feed row for them is one nobody can read, and no
+* override should be able to create it.
+*/
+function candidateChannels(t) {
+	const configurable = [
+		"email",
+		"whatsapp",
+		"sms"
+	];
+	return t.audienceType === "customer" ? configurable : ["in-app", ...configurable];
+}
+/**
+* One module trigger per CHANNEL, each gated on the stored settings.
+*
+* The gate lives in `audience` because that is the only per-event async seam
+* arc gives a trigger, and returning `null` there is already the module's
+* documented "skip" — the same mechanism `extract` uses to filter a broad event.
+*/
+function toGatedNotifyTriggers(t, options, overrides) {
+	const type = t.type ?? t.event;
+	const base = toNotifyTrigger(t, options);
+	const defaults = {
+		recipients: t.recipients,
+		channels: declaredChannels(t),
+		title: t.template.title,
+		message: t.template.message,
+		...t.priority ? { priority: t.priority } : {}
+	};
+	return candidateChannels(t).map((channel) => ({
+		...base,
+		channels: [channel],
+		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);
+			if (!eff.enabled) return null;
+			if (!eff.channels.includes(channel)) return null;
+			if (t.audienceType === "customer") {
+				if (!ex.recipient) return null;
+				return {
+					recipient: ex.recipient,
+					organizationId: ex.organizationId
+				};
+			}
+			if (eff.recipients.length === 0) return null;
+			return {
+				roles: eff.recipients,
+				organizationId: ex.organizationId,
+				...ex.triggeredBy ? { excludeUserId: ex.triggeredBy } : {}
+			};
+		}
+	}));
+}
+/**
+* Adapt a whole registry — what a host assigns to the module's `notifyOn`.
+*
+* With `options.overrides`, each trigger becomes one entry per channel, gated on
+* the admin's stored settings. Without it, the mapping is 1:1 and unchanged.
+*/
+function toNotifyTriggers(triggers, options = {}) {
+	const { overrides } = options;
+	if (!overrides) return triggers.map((t) => toNotifyTrigger(t, options));
+	return triggers.flatMap((t) => toGatedNotifyTriggers(t, options, overrides));
+}
+/**
+* First trigger registered for an event.
+*
+* CAVEAT: an event may carry more than one trigger (an informational alert and
+* an escalation to a different role set both listen to `stock:low`). This
+* returns only the first. For anything that must see all of them — a docs page,
+* an admin matrix, a dispatch count — use `getTriggersByEvent`.
+*/
+function getTriggerByEvent(triggers, event) {
+	return triggers.find((t) => t.event === event);
+}
+/** Every trigger registered for an event, in registration order. */
+function getTriggersByEvent(triggers, event) {
+	return triggers.filter((t) => t.event === event);
+}
+/** Distinct event names the registry subscribes to (for docs / admin UI). */
+function getRegisteredEvents(triggers) {
+	return [...new Set(triggers.map((t) => t.event))];
+}
+/**
+* Notification kind → recipient roles (for the admin UI).
+*
+* Keyed by `type ?? event`, so two triggers sharing an event stay distinct
+* rows — which is exactly why they carry different `type`s.
+*/
+function getRecipientMatrix(triggers) {
+	const matrix = {};
+	for (const t of triggers) matrix[t.type ?? t.event] = t.recipients;
+	return matrix;
+}
+//#endregion
+export { DEFAULT_ENTITY_ID_VARS, INAPP_DATA_KEY, InAppChannel, NOTIFICATION_CHANNELS, SseChannel, createCachedTriggerOverrideStore, createDbFirstResolver, createInAppBackfill, createRepositoryDeliveryLog, createUnreadCountCache, dispatchTrigger, getRecipientMatrix, getRegisteredEvents, getTriggerByEvent, getTriggersByEvent, inAppFeedResource, notificationsJob, notificationsModule, readInAppContent, renderInApp, resolveEffectiveSettings, templatesResource, toNotifyTrigger, toNotifyTriggers };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/arc-notifications",
-  "version": "0.2.0",
+  "version": "0.4.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": {
@@ -24,14 +24,15 @@
   "scripts": {
     "build": "tsdown",
     "typecheck": "tsc --noEmit",
+    "test": "vitest run --root ../.. packages/arc-notifications/tests",
     "lint": "biome check src/",
     "prepublishOnly": "node ../../scripts/prepublish-gate.mjs"
   },
   "peerDependencies": {
-    "@classytic/arc": ">=2.22.0",
-    "@classytic/notifications": ">=2.2.0",
-    "@classytic/primitives": ">=0.11.0",
-    "@classytic/repo-core": ">=0.13.0"
+    "@classytic/arc": ">=2.33.0",
+    "@classytic/notifications": ">=2.4.0",
+    "@classytic/primitives": ">=0.23.0",
+    "@classytic/repo-core": ">=0.24.0"
   },
   "keywords": [
     "arc",
@@ -45,7 +46,7 @@
   "author": "Classytic",
   "repository": {
     "type": "git",
-    "url": "https://github.com/classytic/arc-ecosystem.git",
+    "url": "git+https://github.com/classytic/arc-ecosystem.git",
     "directory": "packages/arc-notifications"
   }
 }