@warlock.js/notifications 5.44.0 → 5.46.0

package/esm/errors.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"errors.mjs","names":[],"sources":["../../../../../../../packages/notifications/src/errors.ts"],"sourcesContent":["/**\n * Domain errors for `@warlock.js/notifications`. All extend `Error` directly\n * (no framework HttpError) so the package stays runtime-agnostic — the host\n * app maps them to its own error shape via `instanceof` if needed.\n *\n * Each captures a clean V8 stack (drops the Error-constructor frame) to match\n * the cascade convention.\n */\n\nfunction captureStack(target: object, ctor: new (...args: any[]) => unknown): void {\n  // V8 only; guarded for non-V8 runtimes.\n  (Error as unknown as { captureStackTrace?: (t: object, c: unknown) => void }).captureStackTrace?.(\n    target,\n    ctor,\n  );\n}\n\nexport class NotificationsNotConfiguredError extends Error {\n  public constructor() {\n    super(\n      \"Notifications not configured — add `src/config/notifications.ts` with a \" +\n        \"default-exported config; the notifications connector registers it at boot.\",\n    );\n    this.name = \"NotificationsNotConfiguredError\";\n    captureStack(this, NotificationsNotConfiguredError);\n  }\n}\n\nexport class ChannelNotFoundError extends Error {\n  public constructor(channelName: string) {\n    super(\n      `Channel \"${channelName}\" is not configured. Add it to the ` +\n        \"`channels` map in `src/config/notifications.ts`.\",\n    );\n    this.name = \"ChannelNotFoundError\";\n    captureStack(this, ChannelNotFoundError);\n  }\n}\n\nexport class NoQueueDispatcherError extends Error {\n  public constructor(channelName: string) {\n    super(\n      `Cannot queue to channel \"${channelName}\" — no queue dispatcher configured. ` +\n        \"Add a `queue` to `src/config/notifications.ts`, or call `.send()` instead of `.queue()`.\",\n    );\n    this.name = \"NoQueueDispatcherError\";\n    captureStack(this, NoQueueDispatcherError);\n  }\n}\n\nexport class MissingRendererError extends Error {\n  public constructor(notificationType: string, channelName: string) {\n    super(\n      `Notification \"${notificationType}\" routes to channel \"${channelName}\" via ` +\n        `\\`via\\` but defines no \\`${channelName}\\` renderer.`,\n    );\n    this.name = \"MissingRendererError\";\n    captureStack(this, MissingRendererError);\n  }\n}\n\n/**\n * Thrown when a channel's `route()` resolver runs but returns `undefined` for\n * a recipient (e.g. a mail recipient with no email). Distinct from \"the\n * channel declares no resolver\" — that case falls back to `{ id }`.\n */\nexport class UnresolvableRouteError extends Error {\n  public constructor(channelName: string, recipientId?: unknown) {\n    super(\n      `Channel \"${channelName}\" could not resolve a route for recipient ` +\n        `${recipientId ?? \"(unknown)\"}. The channel's \\`route()\\` returned undefined — ` +\n        \"the recipient is missing the address column this channel needs.\",\n    );\n    this.name = \"UnresolvableRouteError\";\n    captureStack(this, UnresolvableRouteError);\n  }\n}\n"],"mappings":";;;;;;;;;AASA,SAAS,aAAa,QAAgB,MAA6C;CAEjF,AAAC,MAA6E,oBAC5E,QACA,IACF;AACF;AAEA,IAAa,kCAAb,MAAa,wCAAwC,MAAM;CACzD,AAAO,cAAc;EACnB,MACE,oJAEF;EACA,KAAK,OAAO;EACZ,aAAa,MAAM,+BAA+B;CACpD;AACF;AAEA,IAAa,uBAAb,MAAa,6BAA6B,MAAM;CAC9C,AAAO,YAAY,aAAqB;EACtC,MACE,YAAY,YAAY,wFAE1B;EACA,KAAK,OAAO;EACZ,aAAa,MAAM,oBAAoB;CACzC;AACF;AAEA,IAAa,yBAAb,MAAa,+BAA+B,MAAM;CAChD,AAAO,YAAY,aAAqB;EACtC,MACE,4BAA4B,YAAY,qIAE1C;EACA,KAAK,OAAO;EACZ,aAAa,MAAM,sBAAsB;CAC3C;AACF;AAEA,IAAa,uBAAb,MAAa,6BAA6B,MAAM;CAC9C,AAAO,YAAY,kBAA0B,aAAqB;EAChE,MACE,iBAAiB,iBAAiB,uBAAuB,YAAY,iCACvC,YAAY,aAC5C;EACA,KAAK,OAAO;EACZ,aAAa,MAAM,oBAAoB;CACzC;AACF;;;;;;AAOA,IAAa,yBAAb,MAAa,+BAA+B,MAAM;CAChD,AAAO,YAAY,aAAqB,aAAuB;EAC7D,MACE,YAAY,YAAY,4CACnB,eAAe,YAAY,iHAElC;EACA,KAAK,OAAO;EACZ,aAAa,MAAM,sBAAsB;CAC3C;AACF"}
+{"version":3,"file":"errors.mjs","names":[],"sources":["../../../../../../../packages/notifications/src/errors.ts"],"sourcesContent":["/**\n * Domain errors for `@warlock.js/notifications`. All extend `Error` directly\n * (no framework HttpError) so the package stays runtime-agnostic — the host\n * app maps them to its own error shape via `instanceof` if needed.\n *\n * Each captures a clean V8 stack (drops the Error-constructor frame) to match\n * the cascade convention.\n */\n\nfunction captureStack(target: object, ctor: new (...args: any[]) => unknown): void {\n  // V8 only; guarded for non-V8 runtimes.\n  (Error as unknown as { captureStackTrace?: (t: object, c: unknown) => void }).captureStackTrace?.(\n    target,\n    ctor,\n  );\n}\n\nexport class NotificationsNotConfiguredError extends Error {\n  public constructor() {\n    super(\n      \"Notifications not configured — add `src/config/notifications.ts` with a \" +\n        \"default-exported config; the notifications connector registers it at boot.\",\n    );\n    this.name = \"NotificationsNotConfiguredError\";\n    captureStack(this, NotificationsNotConfiguredError);\n  }\n}\n\nexport class ChannelNotFoundError extends Error {\n  public constructor(channelName: string) {\n    super(\n      `Channel \"${channelName}\" is not configured. Add it to the ` +\n        \"`channels` map in `src/config/notifications.ts`.\",\n    );\n    this.name = \"ChannelNotFoundError\";\n    captureStack(this, ChannelNotFoundError);\n  }\n}\n\nexport class NoQueueDispatcherError extends Error {\n  public constructor(channelName: string) {\n    super(\n      `Cannot queue to channel \"${channelName}\" — no queue dispatcher configured. ` +\n        \"Add a `queue` to `src/config/notifications.ts`, or call `.send()` instead of `.queue()`.\",\n    );\n    this.name = \"NoQueueDispatcherError\";\n    captureStack(this, NoQueueDispatcherError);\n  }\n}\n\nexport class MissingRendererError extends Error {\n  public constructor(notificationType: string, channelName: string) {\n    super(\n      `Notification \"${notificationType}\" routes to channel \"${channelName}\" via ` +\n        `\\`via\\` but defines no \\`${channelName}\\` renderer.`,\n    );\n    this.name = \"MissingRendererError\";\n    captureStack(this, MissingRendererError);\n  }\n}\n\n/**\n * Thrown when a channel's `route()` resolver runs but returns `undefined` for\n * a recipient (e.g. a mail recipient with no email). Distinct from \"the\n * channel declares no resolver\" — that case falls back to `{ id }`.\n */\nexport class UnresolvableRouteError extends Error {\n  public constructor(channelName: string, recipientId?: unknown) {\n    super(\n      `Channel \"${channelName}\" could not resolve a route for recipient ` +\n        `${recipientId ?? \"(unknown)\"}. The channel's \\`route()\\` returned undefined — ` +\n        \"the recipient is missing the address column this channel needs.\",\n    );\n    this.name = \"UnresolvableRouteError\";\n    captureStack(this, UnresolvableRouteError);\n  }\n}\n\n/**\n * Thrown when the notification table keys recipients by type and a read or\n * write names the recipient by a bare id. A bare id cannot say which identity\n * type it belongs to, so serving it would let types sharing that id read each\n * other's notifications. Pass the recipient model, or `{ type, id }`.\n */\nexport class RecipientTypeRequiredError extends Error {\n  public constructor(recipientId?: unknown) {\n    super(\n      `The notifications table stores a recipient type, so recipient ${recipientId ?? \"(unknown)\"} ` +\n        \"must be given as the model or as `{ type, id }`, not as a bare id.\",\n    );\n    this.name = \"RecipientTypeRequiredError\";\n    captureStack(this, RecipientTypeRequiredError);\n  }\n}\n"],"mappings":";;;;;;;;;AASA,SAAS,aAAa,QAAgB,MAA6C;CAEjF,AAAC,MAA6E,oBAC5E,QACA,IACF;AACF;AAEA,IAAa,kCAAb,MAAa,wCAAwC,MAAM;CACzD,AAAO,cAAc;EACnB,MACE,oJAEF;EACA,KAAK,OAAO;EACZ,aAAa,MAAM,+BAA+B;CACpD;AACF;AAEA,IAAa,uBAAb,MAAa,6BAA6B,MAAM;CAC9C,AAAO,YAAY,aAAqB;EACtC,MACE,YAAY,YAAY,wFAE1B;EACA,KAAK,OAAO;EACZ,aAAa,MAAM,oBAAoB;CACzC;AACF;AAEA,IAAa,yBAAb,MAAa,+BAA+B,MAAM;CAChD,AAAO,YAAY,aAAqB;EACtC,MACE,4BAA4B,YAAY,qIAE1C;EACA,KAAK,OAAO;EACZ,aAAa,MAAM,sBAAsB;CAC3C;AACF;AAEA,IAAa,uBAAb,MAAa,6BAA6B,MAAM;CAC9C,AAAO,YAAY,kBAA0B,aAAqB;EAChE,MACE,iBAAiB,iBAAiB,uBAAuB,YAAY,iCACvC,YAAY,aAC5C;EACA,KAAK,OAAO;EACZ,aAAa,MAAM,oBAAoB;CACzC;AACF;;;;;;AAOA,IAAa,yBAAb,MAAa,+BAA+B,MAAM;CAChD,AAAO,YAAY,aAAqB,aAAuB;EAC7D,MACE,YAAY,YAAY,4CACnB,eAAe,YAAY,iHAElC;EACA,KAAK,OAAO;EACZ,aAAa,MAAM,sBAAsB;CAC3C;AACF;;;;;;;AAQA,IAAa,6BAAb,MAAa,mCAAmC,MAAM;CACpD,AAAO,YAAY,aAAuB;EACxC,MACE,iEAAiE,eAAe,YAAY,sEAE9F;EACA,KAAK,OAAO;EACZ,aAAa,MAAM,0BAA0B;CAC/C;AACF"}

package/esm/in-app/base-notifications-repository.d.mts

@@ -3,6 +3,7 @@ import { NotificationContract } from "../contracts/notification.contract.mjs";
 import "../contracts/index.mjs";
 import { NotificationColumnMapHost } from "./column-map.mjs";
 import { DatabaseNotification } from "./database-notification.mjs";
+import { RecipientInput } from "./recipient.mjs";
 import { FilterRules, RepositoryManager } from "@warlock.js/core";
 //#region ../../packages/notifications/src/in-app/base-notifications-repository.d.ts
 /**
@@ -15,6 +16,8 @@ export type NotificationsFilter = {
   /** Mode-agnostic unread filter — resolves to the model's read-state column. */
   unread?: boolean;
   recipientId?: Id;
+  /** Recipient identity type — only filterable when the model declares `columnMap.recipientType`. */
+  recipientType?: string;
   idempotencyKey?: string;
 };
 /** Class form of a `DatabaseNotification` subclass — what `configure()` accepts. */
@@ -32,6 +35,17 @@ export declare class BaseNotificationsRepository<TModel extends NotificationCont
    * direct filtering only when the model declares those columns.
    */
   private buildFilterBy;
+  /**
+   * Resolve a recipient into the logical filter keys that scope a query to it.
+   * When the model stores a recipient type the scope is `(recipientType,
+   * recipientId)`; a bare id then throws, since an id alone can't say which
+   * identity type it belongs to. Without a type column the scope is the id
+   * alone and any type on the recipient is ignored.
+   */
+  scopeOf(recipient: RecipientInput): {
+    recipientId: Id;
+    recipientType?: string;
+  };
   /**
    * Translate an object keyed by LOGICAL names into one keyed by PHYSICAL
    * columns, using `filterBy` as the lookup. Keys with no `[op, column]` tuple
@@ -63,33 +77,33 @@ export declare class BaseNotificationsRepository<TModel extends NotificationCont
    * the existing row instead of inserting a duplicate. A unique index on the
    * key is the backstop for the rare insert race (we re-fetch on conflict).
    */
-  createFor(recipientId: Id, input: DatabasePayload, tenantId?: Id): Promise<TModel>;
+  createFor(recipient: RecipientInput, input: DatabasePayload, tenantId?: Id): Promise<TModel>;
   /**
    * Bulk-create one row per recipient sharing the same input + tenant. Reserved
    * for the Phase-2 `Channel.sendMany` fan-out hook; not on the per-recipient
    * send path yet.
    */
-  createManyFor(recipientIds: Id[], input: DatabasePayload, tenantId?: Id): Promise<TModel[]>;
+  createManyFor(recipients: RecipientInput[], input: DatabasePayload, tenantId?: Id): Promise<TModel[]>;
   /**
    * Mark rows read — recipient-scoped. `id` omitted → all unread rows for the
    * recipient; `id` given → that one row, still scoped to the recipient. Scoped
    * to unread so a re-mark never overwrites an earlier `read_at` timestamp.
    * Sets whichever read-state column(s) the model declares.
    */
-  markRead(recipientId: Id, id?: Id): Promise<number>;
+  markRead(recipient: RecipientInput, id?: Id): Promise<number>;
   /**
    * Inverse of `markRead`, same recipient-scoping. No unread scope needed —
    * clearing the read-state of an already-unread row is a no-op.
    */
-  markUnread(recipientId: Id, id?: Id): Promise<number>;
+  markUnread(recipient: RecipientInput, id?: Id): Promise<number>;
   /** Find one row for a recipient (read path — `filterBy` maps the keys). */
-  findFor(recipientId: Id, id: Id): Promise<TModel | null>;
+  findFor(recipient: RecipientInput, id: Id): Promise<TModel | null>;
   /**
    * Delete rows — recipient-scoped. `id` omitted → clear all for the
    * recipient; `id` given → that one row.
    */
-  deleteFor(recipientId: Id, id?: Id): Promise<number>;
-  /** Read path — `filterBy` maps `recipientId`/`idempotencyKey` to columns. */
+  deleteFor(recipient: RecipientInput, id?: Id): Promise<number>;
+  /** Read path — `filterBy` maps `recipientId`/`recipientType`/`idempotencyKey` to columns. */
   private firstByIdempotencyKey;
 }
 //#endregion

package/esm/in-app/base-notifications-repository.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"base-notifications-repository.d.mts","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/base-notifications-repository.ts"],"mappings":";;;;;;;;;;;YA2CY;EACV,KAAK;EACL;;EAEA;EACA,cAAc;EACd;;;YAIU,kCAAkC,gBAAgB,wBAC5D;qBAEW,4BACX,eAAe,uBAAuB,8BAC9B,kBAAkB,QAAQ;;mBAEjB;EAEV,UAAU;EAEjB,YAAmB,QAAQ;;MAYhB;;;;;;UASH;;;;;;;;YA2CE,MAAM,KAAK,0BAA0B;;;;;;;;;;;;UAwBvC;;;;;;;;;;;;EAoCK,UAAU,aAAa,IAAI,OAAO,iBAAiB,WAAW,KAAK,QAAQ;;;;;;EAwCjF,cACL,cAAc,MACd,OAAO,iBACP,WAAW,KACV,QAAQ;;;;;;;EAYJ,SAAS,aAAa,IAAI,KAAK,KAAK;;;;;EAwBpC,WAAW,aAAa,IAAI,KAAK,KAAK;;EAmBtC,QAAQ,aAAa,IAAI,IAAI,KAAK,QAAQ;;;;;EAQ1C,UAAU,aAAa,IAAI,KAAK,KAAK;;UAKpC"}
+{"version":3,"file":"base-notifications-repository.d.mts","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/base-notifications-repository.ts"],"mappings":";;;;;;;;;;;;YA6CY;EACV,KAAK;EACL;;EAEA;EACA,cAAc;;EAEd;EACA;;;YAIU,kCAAkC,gBAAgB,wBAC5D;qBAEW,4BACX,eAAe,uBAAuB,8BAC9B,kBAAkB,QAAQ;;mBAEjB;EAEV,UAAU;EAEjB,YAAmB,QAAQ;;MAYhB;;;;;;UASH;;;;;;;;EA+CD,QAAQ,WAAW;IAAmB,aAAa;IAAI;;;;;;;;;YAqBpD,MAAM,KAAK,0BAA0B;;;;;;;;;;;;UAwBvC;;;;;;;;;;;;EAsCK,UACX,WAAW,gBACX,OAAO,iBACP,WAAW,KACV,QAAQ;;;;;;EAyCJ,cACL,YAAY,kBACZ,OAAO,iBACP,WAAW,KACV,QAAQ;;;;;;;EAUJ,SAAS,WAAW,gBAAgB,KAAK,KAAK;;;;;EA4B9C,WAAW,WAAW,gBAAgB,KAAK,KAAK;;EAmBhD,QAAQ,WAAW,gBAAgB,IAAI,KAAK,QAAQ;;;;;EAQpD,UAAU,WAAW,gBAAgB,KAAK,KAAK;;UAO9C"}

package/esm/in-app/base-notifications-repository.mjs

@@ -1,3 +1,5 @@
+import { RecipientTypeRequiredError } from "../errors.mjs";
+import { toRecipientRef } from "./recipient.mjs";
 import { resolveColumnMap } from "./column-map.mjs";
 import { RepositoryManager } from "@warlock.js/core";
 
@@ -51,7 +53,7 @@ var BaseNotificationsRepository = class extends RepositoryManager {
 	* direct filtering only when the model declares those columns.
 	*/
 	buildFilterBy() {
-		const { recipient, tenant, readAt, isRead } = this.columns;
+		const { recipient, recipientType, tenant, readAt, isRead } = this.columns;
 		const rules = {
 			id: "=",
 			type: "=",
@@ -63,12 +65,29 @@ var BaseNotificationsRepository = class extends RepositoryManager {
 				else if (readAt) query.whereNull(readAt);
 			}
 		};
+		if (recipientType) rules.recipientType = ["=", recipientType];
 		if (isRead) rules.isRead = ["=", isRead];
 		if (readAt) rules.readAt = ["=", readAt];
 		if (tenant) rules.tenant = ["=", tenant];
 		return rules;
 	}
 	/**
+	* Resolve a recipient into the logical filter keys that scope a query to it.
+	* When the model stores a recipient type the scope is `(recipientType,
+	* recipientId)`; a bare id then throws, since an id alone can't say which
+	* identity type it belongs to. Without a type column the scope is the id
+	* alone and any type on the recipient is ignored.
+	*/
+	scopeOf(recipient) {
+		const { id, type } = toRecipientRef(recipient);
+		if (!this.columns.recipientType) return { recipientId: id };
+		if (!type) throw new RecipientTypeRequiredError(id);
+		return {
+			recipientId: id,
+			recipientType: type
+		};
+	}
+	/**
 	* Translate an object keyed by LOGICAL names into one keyed by PHYSICAL
 	* columns, using `filterBy` as the lookup. Keys with no `[op, column]` tuple
 	* (e.g. `title`, `body`, `payload`, `type`, `id`) pass through unchanged —
@@ -97,10 +116,12 @@ var BaseNotificationsRepository = class extends RepositoryManager {
 	* the recipient column directly.
 	*/
 	stripServerOwnedKeys(input) {
-		const { recipient, tenant, readAt, isRead } = this.columns;
+		const { recipient, recipientType, tenant, readAt, isRead } = this.columns;
 		const serverOwned = /* @__PURE__ */ new Set([
 			"id",
 			"recipientId",
+			"recipientType",
+			recipientType,
 			"tenant",
 			"readAt",
 			"isRead",
@@ -124,15 +145,16 @@ var BaseNotificationsRepository = class extends RepositoryManager {
 	* the existing row instead of inserting a duplicate. A unique index on the
 	* key is the backstop for the rare insert race (we re-fetch on conflict).
 	*/
-	async createFor(recipientId, input, tenantId) {
+	async createFor(recipient, input, tenantId) {
 		const { idempotencyKey } = input;
+		const scope = this.scopeOf(recipient);
 		if (idempotencyKey) {
-			const existing = await this.firstByIdempotencyKey(recipientId, idempotencyKey);
+			const existing = await this.firstByIdempotencyKey(scope, idempotencyKey);
 			if (existing) return existing;
 		}
 		const row = {
 			...this.stripServerOwnedKeys(input),
-			recipientId
+			...scope
 		};
 		if (this.columns.isRead) row.isRead = false;
 		if (this.columns.tenant && tenantId !== void 0) row.tenant = tenantId;
@@ -140,7 +162,7 @@ var BaseNotificationsRepository = class extends RepositoryManager {
 			return await this.create(this.toRow(row));
 		} catch (error) {
 			if (idempotencyKey) {
-				const existing = await this.firstByIdempotencyKey(recipientId, idempotencyKey);
+				const existing = await this.firstByIdempotencyKey(scope, idempotencyKey);
 				if (existing) return existing;
 			}
 			throw error;
@@ -151,8 +173,8 @@ var BaseNotificationsRepository = class extends RepositoryManager {
 	* for the Phase-2 `Channel.sendMany` fan-out hook; not on the per-recipient
 	* send path yet.
 	*/
-	createManyFor(recipientIds, input, tenantId) {
-		return Promise.all(recipientIds.map((recipientId) => this.createFor(recipientId, input, tenantId)));
+	createManyFor(recipients, input, tenantId) {
+		return Promise.all(recipients.map((recipient) => this.createFor(recipient, input, tenantId)));
 	}
 	/**
 	* Mark rows read — recipient-scoped. `id` omitted → all unread rows for the
@@ -160,14 +182,14 @@ var BaseNotificationsRepository = class extends RepositoryManager {
 	* to unread so a re-mark never overwrites an earlier `read_at` timestamp.
 	* Sets whichever read-state column(s) the model declares.
 	*/
-	markRead(recipientId, id) {
+	markRead(recipient, id) {
 		const { isRead, readAt } = this.columns;
 		const unreadScope = isRead ? { isRead: false } : { readAt: null };
 		const data = {};
 		if (isRead) data.isRead = true;
 		if (readAt) data.readAt = /* @__PURE__ */ new Date();
 		return this.updateMany(this.toRow({
-			recipientId,
+			...this.scopeOf(recipient),
 			...unreadScope,
 			...id !== void 0 ? { id } : {}
 		}), this.toRow(data));
@@ -176,20 +198,20 @@ var BaseNotificationsRepository = class extends RepositoryManager {
 	* Inverse of `markRead`, same recipient-scoping. No unread scope needed —
 	* clearing the read-state of an already-unread row is a no-op.
 	*/
-	markUnread(recipientId, id) {
+	markUnread(recipient, id) {
 		const { isRead, readAt } = this.columns;
 		const data = {};
 		if (isRead) data.isRead = false;
 		if (readAt) data.readAt = null;
 		return this.updateMany(this.toRow({
-			recipientId,
+			...this.scopeOf(recipient),
 			...id !== void 0 ? { id } : {}
 		}), this.toRow(data));
 	}
 	/** Find one row for a recipient (read path — `filterBy` maps the keys). */
-	findFor(recipientId, id) {
+	findFor(recipient, id) {
 		return this.first({
-			recipientId,
+			...this.scopeOf(recipient),
 			id
 		});
 	}
@@ -197,16 +219,16 @@ var BaseNotificationsRepository = class extends RepositoryManager {
 	* Delete rows — recipient-scoped. `id` omitted → clear all for the
 	* recipient; `id` given → that one row.
 	*/
-	deleteFor(recipientId, id) {
+	deleteFor(recipient, id) {
 		return this.deleteMany(this.toRow({
-			recipientId,
+			...this.scopeOf(recipient),
 			...id !== void 0 ? { id } : {}
 		}));
 	}
-	/** Read path — `filterBy` maps `recipientId`/`idempotencyKey` to columns. */
-	firstByIdempotencyKey(recipientId, idempotencyKey) {
+	/** Read path — `filterBy` maps `recipientId`/`recipientType`/`idempotencyKey` to columns. */
+	firstByIdempotencyKey(scope, idempotencyKey) {
 		return this.first({
-			recipientId,
+			...scope,
 			idempotencyKey
 		});
 	}

package/esm/in-app/base-notifications-repository.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"base-notifications-repository.mjs","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/base-notifications-repository.ts"],"sourcesContent":["/**\n * Shipped behavior repository for the in-app store.\n *\n * Concrete (NOT abstract) so `inApp.configure({ model })` can\n * `new BaseNotificationsRepository(model)` without subclassing. The dev only\n * extends this when they need extra query methods.\n *\n * ## The single source of truth: the model's `columnMap`\n *\n * The model declares its physical columns ONCE via `static columnMap`. The\n * constructor resolves that map and derives BOTH sides from it:\n *\n *  - the READ path — `filterBy` maps logical keys (`recipientId`, `unread`,\n *    `type`, …) onto the model's columns; `RepositoryManager` applies it.\n *  - the WRITE / UPDATE / DELETE path — `createFor` / `markRead` / … translate\n *    logical keys through the same `filterBy` via `toRow`.\n *\n * Because both come from one `columnMap`, reads and writes can never target\n * different columns. `unread` is mode-agnostic: it filters `is_read = false`\n * when the model has that flag, otherwise `read_at IS NULL`.\n *\n * @example  default (SQL snake_case — no subclass needed)\n *   inApp.configure({ model: Notification })\n *\n * @example  custom columns — declare them on the model, not here\n *   class Notification extends DatabaseNotification {\n *     public static columnMap = { recipient: \"audience_id\", isRead: \"seen\" };\n *   }\n */\nimport { type FilterRules, RepositoryManager } from \"@warlock.js/core\";\nimport type { NotificationContract } from \"../contracts\";\nimport type { DatabasePayload, Id } from \"../types\";\nimport {\n  type NotificationColumnMapHost,\n  type ResolvedNotificationColumnMap,\n  resolveColumnMap,\n} from \"./column-map\";\nimport type { DatabaseNotification } from \"./database-notification\";\n\n/**\n * Filter shape — logical keys the repo understands. `filterBy` maps each to a\n * physical column (or a predicate) derived from the model's `columnMap`.\n */\nexport type NotificationsFilter = {\n  id?: Id;\n  type?: string;\n  /** Mode-agnostic unread filter — resolves to the model's read-state column. */\n  unread?: boolean;\n  recipientId?: Id;\n  idempotencyKey?: string;\n};\n\n/** Class form of a `DatabaseNotification` subclass — what `configure()` accepts. */\nexport type NotificationModelClass = (new (...args: any[]) => DatabaseNotification) &\n  NotificationColumnMapHost;\n\nexport class BaseNotificationsRepository<\n  TModel extends NotificationContract = NotificationContract,\n> extends RepositoryManager<TModel, NotificationsFilter> {\n  /** Resolved physical columns for the bound model — the single source. */\n  private readonly columns: ResolvedNotificationColumnMap;\n\n  public filterBy: FilterRules;\n\n  public constructor(model?: NotificationModelClass) {\n    super();\n\n    if (model) {\n      this.source = model;\n    }\n\n    this.columns = resolveColumnMap(model?.columnMap);\n    this.filterBy = this.buildFilterBy();\n  }\n\n  /** The tenant column for this model, or `undefined` for single-tenant. */\n  public get tenantColumn(): string | undefined {\n    return this.columns.tenant;\n  }\n\n  /**\n   * Build `filterBy` from the resolved column map. `unread` is the\n   * mode-agnostic read filter; `isRead` / `readAt` / `tenant` are exposed for\n   * direct filtering only when the model declares those columns.\n   */\n  private buildFilterBy(): FilterRules {\n    const { recipient, tenant, readAt, isRead } = this.columns;\n\n    const rules: FilterRules = {\n      id: \"=\",\n      type: \"=\",\n      recipientId: [\"=\", recipient],\n      idempotencyKey: [\"=\", \"idempotency_key\"],\n      unread: (value, query) => {\n        if (value !== true && value !== \"true\") {\n          return;\n        }\n\n        if (isRead) {\n          query.where(isRead, false);\n        } else if (readAt) {\n          query.whereNull(readAt);\n        }\n      },\n    };\n\n    if (isRead) {\n      rules.isRead = [\"=\", isRead];\n    }\n\n    if (readAt) {\n      rules.readAt = [\"=\", readAt];\n    }\n\n    if (tenant) {\n      rules.tenant = [\"=\", tenant];\n    }\n\n    return rules;\n  }\n\n  /**\n   * Translate an object keyed by LOGICAL names into one keyed by PHYSICAL\n   * columns, using `filterBy` as the lookup. Keys with no `[op, column]` tuple\n   * (e.g. `title`, `body`, `payload`, `type`, `id`) pass through unchanged —\n   * they're already physical. Used for every write / update / delete payload +\n   * filter (the paths `RepositoryManager` does NOT map).\n   */\n  protected toRow(obj: Record<string, unknown>): Record<string, unknown> {\n    const rules = this.filterBy as Record<string, unknown>;\n    const row: Record<string, unknown> = {};\n\n    for (const [logical, value] of Object.entries(obj)) {\n      const rule = rules[logical];\n      const column = Array.isArray(rule) ? (rule[1] as string) : logical;\n      row[column] = value;\n    }\n\n    return row;\n  }\n\n  /**\n   * Runtime backstop for the compile-time `DatabasePayload` `Omit`: untyped\n   * callers (`notify.channel(name).send`, payloads assembled from request\n   * JSON) can smuggle server-owned keys past the type system, and spreading\n   * them into the row would let a payload redirect the notification into\n   * another recipient's inbox (recipient spoofing), cross tenants, pre-set\n   * read-state, or clobber the primary key. Drops BOTH the logical names and\n   * the model's resolved physical columns — `toRow` passes unmapped keys\n   * through verbatim, so a payload carrying `user_id` would otherwise reach\n   * the recipient column directly.\n   */\n  private stripServerOwnedKeys(input: DatabasePayload): Record<string, unknown> {\n    const { recipient, tenant, readAt, isRead } = this.columns;\n    const serverOwned = new Set<string | undefined>([\n      \"id\",\n      \"recipientId\",\n      \"tenant\",\n      \"readAt\",\n      \"isRead\",\n      recipient,\n      tenant,\n      readAt,\n      isRead,\n    ]);\n\n    const safe: Record<string, unknown> = {};\n\n    for (const [key, value] of Object.entries(input)) {\n      if (!serverOwned.has(key)) {\n        safe[key] = value;\n      }\n    }\n\n    return safe;\n  }\n\n  /**\n   * Create one row for the recipient. New rows start unread; the tenant column\n   * (when the model declares one) is written from `tenantId`, which the\n   * database channel reads off the recipient. `recipientId` and the other\n   * server-owned keys always come from the trusted arguments — matching keys\n   * in `input` are stripped, never merged.\n   *\n   * Idempotency: when `input.idempotencyKey` is set, find-or-create — return\n   * the existing row instead of inserting a duplicate. A unique index on the\n   * key is the backstop for the rare insert race (we re-fetch on conflict).\n   */\n  public async createFor(recipientId: Id, input: DatabasePayload, tenantId?: Id): Promise<TModel> {\n    const { idempotencyKey } = input;\n\n    if (idempotencyKey) {\n      const existing = await this.firstByIdempotencyKey(recipientId, idempotencyKey);\n      if (existing) {\n        return existing;\n      }\n    }\n\n    const row: Record<string, unknown> = { ...this.stripServerOwnedKeys(input), recipientId };\n\n    if (this.columns.isRead) {\n      row.isRead = false;\n    }\n\n    if (this.columns.tenant && tenantId !== undefined) {\n      row.tenant = tenantId;\n    }\n\n    try {\n      return await this.create(this.toRow(row));\n    } catch (error) {\n      // Lost the insert race to a concurrent send with the same key → re-fetch.\n      if (idempotencyKey) {\n        const existing = await this.firstByIdempotencyKey(recipientId, idempotencyKey);\n        if (existing) {\n          return existing;\n        }\n      }\n\n      throw error;\n    }\n  }\n\n  /**\n   * Bulk-create one row per recipient sharing the same input + tenant. Reserved\n   * for the Phase-2 `Channel.sendMany` fan-out hook; not on the per-recipient\n   * send path yet.\n   */\n  public createManyFor(\n    recipientIds: Id[],\n    input: DatabasePayload,\n    tenantId?: Id,\n  ): Promise<TModel[]> {\n    return Promise.all(\n      recipientIds.map((recipientId) => this.createFor(recipientId, input, tenantId)),\n    );\n  }\n\n  /**\n   * Mark rows read — recipient-scoped. `id` omitted → all unread rows for the\n   * recipient; `id` given → that one row, still scoped to the recipient. Scoped\n   * to unread so a re-mark never overwrites an earlier `read_at` timestamp.\n   * Sets whichever read-state column(s) the model declares.\n   */\n  public markRead(recipientId: Id, id?: Id): Promise<number> {\n    const { isRead, readAt } = this.columns;\n    const unreadScope = isRead ? { isRead: false } : { readAt: null };\n\n    const data: Record<string, unknown> = {};\n\n    if (isRead) {\n      data.isRead = true;\n    }\n\n    if (readAt) {\n      data.readAt = new Date();\n    }\n\n    return this.updateMany(\n      this.toRow({ recipientId, ...unreadScope, ...(id !== undefined ? { id } : {}) }),\n      this.toRow(data),\n    );\n  }\n\n  /**\n   * Inverse of `markRead`, same recipient-scoping. No unread scope needed —\n   * clearing the read-state of an already-unread row is a no-op.\n   */\n  public markUnread(recipientId: Id, id?: Id): Promise<number> {\n    const { isRead, readAt } = this.columns;\n    const data: Record<string, unknown> = {};\n\n    if (isRead) {\n      data.isRead = false;\n    }\n\n    if (readAt) {\n      data.readAt = null;\n    }\n\n    return this.updateMany(\n      this.toRow({ recipientId, ...(id !== undefined ? { id } : {}) }),\n      this.toRow(data),\n    );\n  }\n\n  /** Find one row for a recipient (read path — `filterBy` maps the keys). */\n  public findFor(recipientId: Id, id: Id): Promise<TModel | null> {\n    return this.first({ recipientId, id } as NotificationsFilter);\n  }\n\n  /**\n   * Delete rows — recipient-scoped. `id` omitted → clear all for the\n   * recipient; `id` given → that one row.\n   */\n  public deleteFor(recipientId: Id, id?: Id): Promise<number> {\n    return this.deleteMany(this.toRow({ recipientId, ...(id !== undefined ? { id } : {}) }));\n  }\n\n  /** Read path — `filterBy` maps `recipientId`/`idempotencyKey` to columns. */\n  private firstByIdempotencyKey(recipientId: Id, idempotencyKey: string): Promise<TModel | null> {\n    return this.first({ recipientId, idempotencyKey } as NotificationsFilter);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,IAAa,8BAAb,cAEU,kBAA+C;;CAEvD,AAAiB;CAEjB,AAAO;CAEP,AAAO,YAAY,OAAgC;EACjD,MAAM;EAEN,IAAI,OACF,KAAK,SAAS;EAGhB,KAAK,UAAU,iBAAiB,OAAO,SAAS;EAChD,KAAK,WAAW,KAAK,cAAc;CACrC;;CAGA,IAAW,eAAmC;EAC5C,OAAO,KAAK,QAAQ;CACtB;;;;;;CAOA,AAAQ,gBAA6B;EACnC,MAAM,EAAE,WAAW,QAAQ,QAAQ,WAAW,KAAK;EAEnD,MAAM,QAAqB;GACzB,IAAI;GACJ,MAAM;GACN,aAAa,CAAC,KAAK,SAAS;GAC5B,gBAAgB,CAAC,KAAK,iBAAiB;GACvC,SAAS,OAAO,UAAU;IACxB,IAAI,UAAU,QAAQ,UAAU,QAC9B;IAGF,IAAI,QACF,MAAM,MAAM,QAAQ,KAAK;SACpB,IAAI,QACT,MAAM,UAAU,MAAM;GAE1B;EACF;EAEA,IAAI,QACF,MAAM,SAAS,CAAC,KAAK,MAAM;EAG7B,IAAI,QACF,MAAM,SAAS,CAAC,KAAK,MAAM;EAG7B,IAAI,QACF,MAAM,SAAS,CAAC,KAAK,MAAM;EAG7B,OAAO;CACT;;;;;;;;CASA,AAAU,MAAM,KAAuD;EACrE,MAAM,QAAQ,KAAK;EACnB,MAAM,MAA+B,CAAC;EAEtC,KAAK,MAAM,CAAC,SAAS,UAAU,OAAO,QAAQ,GAAG,GAAG;GAClD,MAAM,OAAO,MAAM;GACnB,MAAM,SAAS,MAAM,QAAQ,IAAI,IAAK,KAAK,KAAgB;GAC3D,IAAI,UAAU;EAChB;EAEA,OAAO;CACT;;;;;;;;;;;;CAaA,AAAQ,qBAAqB,OAAiD;EAC5E,MAAM,EAAE,WAAW,QAAQ,QAAQ,WAAW,KAAK;EACnD,MAAM,8BAAc,IAAI,IAAwB;GAC9C;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;EACF,CAAC;EAED,MAAM,OAAgC,CAAC;EAEvC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAC7C,IAAI,CAAC,YAAY,IAAI,GAAG,GACtB,KAAK,OAAO;EAIhB,OAAO;CACT;;;;;;;;;;;;CAaA,MAAa,UAAU,aAAiB,OAAwB,UAAgC;EAC9F,MAAM,EAAE,mBAAmB;EAE3B,IAAI,gBAAgB;GAClB,MAAM,WAAW,MAAM,KAAK,sBAAsB,aAAa,cAAc;GAC7E,IAAI,UACF,OAAO;EAEX;EAEA,MAAM,MAA+B;GAAE,GAAG,KAAK,qBAAqB,KAAK;GAAG;EAAY;EAExF,IAAI,KAAK,QAAQ,QACf,IAAI,SAAS;EAGf,IAAI,KAAK,QAAQ,UAAU,aAAa,QACtC,IAAI,SAAS;EAGf,IAAI;GACF,OAAO,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG,CAAC;EAC1C,SAAS,OAAO;GAEd,IAAI,gBAAgB;IAClB,MAAM,WAAW,MAAM,KAAK,sBAAsB,aAAa,cAAc;IAC7E,IAAI,UACF,OAAO;GAEX;GAEA,MAAM;EACR;CACF;;;;;;CAOA,AAAO,cACL,cACA,OACA,UACmB;EACnB,OAAO,QAAQ,IACb,aAAa,KAAK,gBAAgB,KAAK,UAAU,aAAa,OAAO,QAAQ,CAAC,CAChF;CACF;;;;;;;CAQA,AAAO,SAAS,aAAiB,IAA0B;EACzD,MAAM,EAAE,QAAQ,WAAW,KAAK;EAChC,MAAM,cAAc,SAAS,EAAE,QAAQ,MAAM,IAAI,EAAE,QAAQ,KAAK;EAEhE,MAAM,OAAgC,CAAC;EAEvC,IAAI,QACF,KAAK,SAAS;EAGhB,IAAI,QACF,KAAK,yBAAS,IAAI,KAAK;EAGzB,OAAO,KAAK,WACV,KAAK,MAAM;GAAE;GAAa,GAAG;GAAa,GAAI,OAAO,SAAY,EAAE,GAAG,IAAI,CAAC;EAAG,CAAC,GAC/E,KAAK,MAAM,IAAI,CACjB;CACF;;;;;CAMA,AAAO,WAAW,aAAiB,IAA0B;EAC3D,MAAM,EAAE,QAAQ,WAAW,KAAK;EAChC,MAAM,OAAgC,CAAC;EAEvC,IAAI,QACF,KAAK,SAAS;EAGhB,IAAI,QACF,KAAK,SAAS;EAGhB,OAAO,KAAK,WACV,KAAK,MAAM;GAAE;GAAa,GAAI,OAAO,SAAY,EAAE,GAAG,IAAI,CAAC;EAAG,CAAC,GAC/D,KAAK,MAAM,IAAI,CACjB;CACF;;CAGA,AAAO,QAAQ,aAAiB,IAAgC;EAC9D,OAAO,KAAK,MAAM;GAAE;GAAa;EAAG,CAAwB;CAC9D;;;;;CAMA,AAAO,UAAU,aAAiB,IAA0B;EAC1D,OAAO,KAAK,WAAW,KAAK,MAAM;GAAE;GAAa,GAAI,OAAO,SAAY,EAAE,GAAG,IAAI,CAAC;EAAG,CAAC,CAAC;CACzF;;CAGA,AAAQ,sBAAsB,aAAiB,gBAAgD;EAC7F,OAAO,KAAK,MAAM;GAAE;GAAa;EAAe,CAAwB;CAC1E;AACF"}
+{"version":3,"file":"base-notifications-repository.mjs","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/base-notifications-repository.ts"],"sourcesContent":["/**\n * Shipped behavior repository for the in-app store.\n *\n * Concrete (NOT abstract) so `inApp.configure({ model })` can\n * `new BaseNotificationsRepository(model)` without subclassing. The dev only\n * extends this when they need extra query methods.\n *\n * ## The single source of truth: the model's `columnMap`\n *\n * The model declares its physical columns ONCE via `static columnMap`. The\n * constructor resolves that map and derives BOTH sides from it:\n *\n *  - the READ path — `filterBy` maps logical keys (`recipientId`, `unread`,\n *    `type`, …) onto the model's columns; `RepositoryManager` applies it.\n *  - the WRITE / UPDATE / DELETE path — `createFor` / `markRead` / … translate\n *    logical keys through the same `filterBy` via `toRow`.\n *\n * Because both come from one `columnMap`, reads and writes can never target\n * different columns. `unread` is mode-agnostic: it filters `is_read = false`\n * when the model has that flag, otherwise `read_at IS NULL`.\n *\n * @example  default (SQL snake_case — no subclass needed)\n *   inApp.configure({ model: Notification })\n *\n * @example  custom columns — declare them on the model, not here\n *   class Notification extends DatabaseNotification {\n *     public static columnMap = { recipient: \"audience_id\", isRead: \"seen\" };\n *   }\n */\nimport { type FilterRules, RepositoryManager } from \"@warlock.js/core\";\nimport type { NotificationContract } from \"../contracts\";\nimport { RecipientTypeRequiredError } from \"../errors\";\nimport type { DatabasePayload, Id } from \"../types\";\nimport {\n  type NotificationColumnMapHost,\n  type ResolvedNotificationColumnMap,\n  resolveColumnMap,\n} from \"./column-map\";\nimport type { DatabaseNotification } from \"./database-notification\";\nimport { type RecipientInput, toRecipientRef } from \"./recipient\";\n\n/**\n * Filter shape — logical keys the repo understands. `filterBy` maps each to a\n * physical column (or a predicate) derived from the model's `columnMap`.\n */\nexport type NotificationsFilter = {\n  id?: Id;\n  type?: string;\n  /** Mode-agnostic unread filter — resolves to the model's read-state column. */\n  unread?: boolean;\n  recipientId?: Id;\n  /** Recipient identity type — only filterable when the model declares `columnMap.recipientType`. */\n  recipientType?: string;\n  idempotencyKey?: string;\n};\n\n/** Class form of a `DatabaseNotification` subclass — what `configure()` accepts. */\nexport type NotificationModelClass = (new (...args: any[]) => DatabaseNotification) &\n  NotificationColumnMapHost;\n\nexport class BaseNotificationsRepository<\n  TModel extends NotificationContract = NotificationContract,\n> extends RepositoryManager<TModel, NotificationsFilter> {\n  /** Resolved physical columns for the bound model — the single source. */\n  private readonly columns: ResolvedNotificationColumnMap;\n\n  public filterBy: FilterRules;\n\n  public constructor(model?: NotificationModelClass) {\n    super();\n\n    if (model) {\n      this.source = model;\n    }\n\n    this.columns = resolveColumnMap(model?.columnMap);\n    this.filterBy = this.buildFilterBy();\n  }\n\n  /** The tenant column for this model, or `undefined` for single-tenant. */\n  public get tenantColumn(): string | undefined {\n    return this.columns.tenant;\n  }\n\n  /**\n   * Build `filterBy` from the resolved column map. `unread` is the\n   * mode-agnostic read filter; `isRead` / `readAt` / `tenant` are exposed for\n   * direct filtering only when the model declares those columns.\n   */\n  private buildFilterBy(): FilterRules {\n    const { recipient, recipientType, tenant, readAt, isRead } = this.columns;\n\n    const rules: FilterRules = {\n      id: \"=\",\n      type: \"=\",\n      recipientId: [\"=\", recipient],\n      idempotencyKey: [\"=\", \"idempotency_key\"],\n      unread: (value, query) => {\n        if (value !== true && value !== \"true\") {\n          return;\n        }\n\n        if (isRead) {\n          query.where(isRead, false);\n        } else if (readAt) {\n          query.whereNull(readAt);\n        }\n      },\n    };\n\n    if (recipientType) {\n      rules.recipientType = [\"=\", recipientType];\n    }\n\n    if (isRead) {\n      rules.isRead = [\"=\", isRead];\n    }\n\n    if (readAt) {\n      rules.readAt = [\"=\", readAt];\n    }\n\n    if (tenant) {\n      rules.tenant = [\"=\", tenant];\n    }\n\n    return rules;\n  }\n\n  /**\n   * Resolve a recipient into the logical filter keys that scope a query to it.\n   * When the model stores a recipient type the scope is `(recipientType,\n   * recipientId)`; a bare id then throws, since an id alone can't say which\n   * identity type it belongs to. Without a type column the scope is the id\n   * alone and any type on the recipient is ignored.\n   */\n  public scopeOf(recipient: RecipientInput): { recipientId: Id; recipientType?: string } {\n    const { id, type } = toRecipientRef(recipient);\n\n    if (!this.columns.recipientType) {\n      return { recipientId: id };\n    }\n\n    if (!type) {\n      throw new RecipientTypeRequiredError(id);\n    }\n\n    return { recipientId: id, recipientType: type };\n  }\n\n  /**\n   * Translate an object keyed by LOGICAL names into one keyed by PHYSICAL\n   * columns, using `filterBy` as the lookup. Keys with no `[op, column]` tuple\n   * (e.g. `title`, `body`, `payload`, `type`, `id`) pass through unchanged —\n   * they're already physical. Used for every write / update / delete payload +\n   * filter (the paths `RepositoryManager` does NOT map).\n   */\n  protected toRow(obj: Record<string, unknown>): Record<string, unknown> {\n    const rules = this.filterBy as Record<string, unknown>;\n    const row: Record<string, unknown> = {};\n\n    for (const [logical, value] of Object.entries(obj)) {\n      const rule = rules[logical];\n      const column = Array.isArray(rule) ? (rule[1] as string) : logical;\n      row[column] = value;\n    }\n\n    return row;\n  }\n\n  /**\n   * Runtime backstop for the compile-time `DatabasePayload` `Omit`: untyped\n   * callers (`notify.channel(name).send`, payloads assembled from request\n   * JSON) can smuggle server-owned keys past the type system, and spreading\n   * them into the row would let a payload redirect the notification into\n   * another recipient's inbox (recipient spoofing), cross tenants, pre-set\n   * read-state, or clobber the primary key. Drops BOTH the logical names and\n   * the model's resolved physical columns — `toRow` passes unmapped keys\n   * through verbatim, so a payload carrying `user_id` would otherwise reach\n   * the recipient column directly.\n   */\n  private stripServerOwnedKeys(input: DatabasePayload): Record<string, unknown> {\n    const { recipient, recipientType, tenant, readAt, isRead } = this.columns;\n    const serverOwned = new Set<string | undefined>([\n      \"id\",\n      \"recipientId\",\n      \"recipientType\",\n      recipientType,\n      \"tenant\",\n      \"readAt\",\n      \"isRead\",\n      recipient,\n      tenant,\n      readAt,\n      isRead,\n    ]);\n\n    const safe: Record<string, unknown> = {};\n\n    for (const [key, value] of Object.entries(input)) {\n      if (!serverOwned.has(key)) {\n        safe[key] = value;\n      }\n    }\n\n    return safe;\n  }\n\n  /**\n   * Create one row for the recipient. New rows start unread; the tenant column\n   * (when the model declares one) is written from `tenantId`, which the\n   * database channel reads off the recipient. `recipientId` and the other\n   * server-owned keys always come from the trusted arguments — matching keys\n   * in `input` are stripped, never merged.\n   *\n   * Idempotency: when `input.idempotencyKey` is set, find-or-create — return\n   * the existing row instead of inserting a duplicate. A unique index on the\n   * key is the backstop for the rare insert race (we re-fetch on conflict).\n   */\n  public async createFor(\n    recipient: RecipientInput,\n    input: DatabasePayload,\n    tenantId?: Id,\n  ): Promise<TModel> {\n    const { idempotencyKey } = input;\n    const scope = this.scopeOf(recipient);\n\n    if (idempotencyKey) {\n      const existing = await this.firstByIdempotencyKey(scope, idempotencyKey);\n      if (existing) {\n        return existing;\n      }\n    }\n\n    const row: Record<string, unknown> = { ...this.stripServerOwnedKeys(input), ...scope };\n\n    if (this.columns.isRead) {\n      row.isRead = false;\n    }\n\n    if (this.columns.tenant && tenantId !== undefined) {\n      row.tenant = tenantId;\n    }\n\n    try {\n      return await this.create(this.toRow(row));\n    } catch (error) {\n      // Lost the insert race to a concurrent send with the same key → re-fetch.\n      if (idempotencyKey) {\n        const existing = await this.firstByIdempotencyKey(scope, idempotencyKey);\n        if (existing) {\n          return existing;\n        }\n      }\n\n      throw error;\n    }\n  }\n\n  /**\n   * Bulk-create one row per recipient sharing the same input + tenant. Reserved\n   * for the Phase-2 `Channel.sendMany` fan-out hook; not on the per-recipient\n   * send path yet.\n   */\n  public createManyFor(\n    recipients: RecipientInput[],\n    input: DatabasePayload,\n    tenantId?: Id,\n  ): Promise<TModel[]> {\n    return Promise.all(recipients.map((recipient) => this.createFor(recipient, input, tenantId)));\n  }\n\n  /**\n   * Mark rows read — recipient-scoped. `id` omitted → all unread rows for the\n   * recipient; `id` given → that one row, still scoped to the recipient. Scoped\n   * to unread so a re-mark never overwrites an earlier `read_at` timestamp.\n   * Sets whichever read-state column(s) the model declares.\n   */\n  public markRead(recipient: RecipientInput, id?: Id): Promise<number> {\n    const { isRead, readAt } = this.columns;\n    const unreadScope = isRead ? { isRead: false } : { readAt: null };\n\n    const data: Record<string, unknown> = {};\n\n    if (isRead) {\n      data.isRead = true;\n    }\n\n    if (readAt) {\n      data.readAt = new Date();\n    }\n\n    return this.updateMany(\n      this.toRow({\n        ...this.scopeOf(recipient),\n        ...unreadScope,\n        ...(id !== undefined ? { id } : {}),\n      }),\n      this.toRow(data),\n    );\n  }\n\n  /**\n   * Inverse of `markRead`, same recipient-scoping. No unread scope needed —\n   * clearing the read-state of an already-unread row is a no-op.\n   */\n  public markUnread(recipient: RecipientInput, id?: Id): Promise<number> {\n    const { isRead, readAt } = this.columns;\n    const data: Record<string, unknown> = {};\n\n    if (isRead) {\n      data.isRead = false;\n    }\n\n    if (readAt) {\n      data.readAt = null;\n    }\n\n    return this.updateMany(\n      this.toRow({ ...this.scopeOf(recipient), ...(id !== undefined ? { id } : {}) }),\n      this.toRow(data),\n    );\n  }\n\n  /** Find one row for a recipient (read path — `filterBy` maps the keys). */\n  public findFor(recipient: RecipientInput, id: Id): Promise<TModel | null> {\n    return this.first({ ...this.scopeOf(recipient), id } as NotificationsFilter);\n  }\n\n  /**\n   * Delete rows — recipient-scoped. `id` omitted → clear all for the\n   * recipient; `id` given → that one row.\n   */\n  public deleteFor(recipient: RecipientInput, id?: Id): Promise<number> {\n    return this.deleteMany(\n      this.toRow({ ...this.scopeOf(recipient), ...(id !== undefined ? { id } : {}) }),\n    );\n  }\n\n  /** Read path — `filterBy` maps `recipientId`/`recipientType`/`idempotencyKey` to columns. */\n  private firstByIdempotencyKey(\n    scope: { recipientId: Id; recipientType?: string },\n    idempotencyKey: string,\n  ): Promise<TModel | null> {\n    return this.first({ ...scope, idempotencyKey } as NotificationsFilter);\n  }\n}\n"],"mappings":"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"}

package/esm/in-app/column-map.d.mts

@@ -35,6 +35,13 @@
 export type NotificationColumnMap = {
   /** Recipient FK column. Default: `"user_id"`. */
   recipient?: string;
+  /**
+   * Recipient TYPE column (e.g. `"recipient_type"`). Declare it to key every
+   * notification by `(type, id)` so identities of different types that share an
+   * id (staff 5 vs customer 5) never read each other's rows. Omit → ids are
+   * the only key (single-identity apps, tables created before the column).
+   */
+  recipientType?: string;
   /** Multi-tenant scope column, written from the recipient. Omit → single-tenant. */
   tenant?: string;
   /** Read-timestamp column. Present → read-state records "when". */
@@ -49,6 +56,7 @@ export type NotificationColumnMap = {
  */
 export type ResolvedNotificationColumnMap = {
   recipient: string;
+  recipientType?: string;
   tenant?: string;
   readAt?: string;
   isRead?: string;

package/esm/in-app/column-map.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"column-map.d.mts","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/column-map.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkCY;;EAEV;;EAEA;;EAEA;;EAEA;;;;;;;YAQU;EACV;EACA;EACA;EACA;;;YAIU;EACV,YAAY;;;;;;;;wBAYE,iBACd,KAAK,oCACJ"}
+{"version":3,"file":"column-map.d.mts","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/column-map.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkCY;;EAEV;;;;;;;EAOA;;EAEA;;EAEA;;EAEA;;;;;;;YAQU;EACV;EACA;EACA;EACA;EACA;;;YAIU;EACV,YAAY;;;;;;;;wBAYE,iBACd,KAAK,oCACJ"}

package/esm/in-app/column-map.mjs

@@ -10,13 +10,16 @@ const DEFAULT_READ_AT_COLUMN = "read_at";
 function resolveColumnMap(map) {
 	const recipient = map?.recipient ?? DEFAULT_RECIPIENT_COLUMN;
 	const tenant = map?.tenant;
+	const recipientType = map?.recipientType;
 	if (!map?.readAt && !map?.isRead) return {
 		recipient,
+		recipientType,
 		tenant,
 		readAt: DEFAULT_READ_AT_COLUMN
 	};
 	return {
 		recipient,
+		recipientType,
 		tenant,
 		readAt: map.readAt,
 		isRead: map.isRead

package/esm/in-app/column-map.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"column-map.mjs","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/column-map.ts"],"sourcesContent":["/**\n * `columnMap` — how a notification model's logical roles map to the physical\n * columns of ITS table. The ONE source the model getters, the repository\n * (read filter + write mapping), the database channel, and the migration\n * factory all read, so they can never drift apart.\n *\n * Declared as a `static columnMap` on the model and ejected to userland, so\n * the dev owns it:\n *\n *   @RegisterModel()\n *   export class Notification extends DatabaseNotification {\n *     public static table = \"notifications\";\n *     public static columnMap: NotificationColumnMap = {\n *       tenant: \"organization_id\", // omit → single-tenant\n *       readAt: \"read_at\",         // read-state (see below)\n *     };\n *   }\n *\n * ## Read-state is chosen by which keys are PRESENT\n *\n * - `readAt` only → unread = `read_at IS NULL`; marking read stamps it.\n * - `isRead` only → unread = `is_read = false`; no timestamp.\n * - both        → `is_read` is the indexed flag used for filtering, `read_at`\n *                 records WHEN; marking read sets both.\n *\n * Declare neither and you get the `readAt`-only default — so a model can omit\n * `columnMap` entirely and still work.\n */\n\n/**\n * The logical → physical column bindings a notification model may declare.\n * Every key is optional; `resolveColumnMap` fills the defaults. Values are the\n * app's real column names (rename-friendly: `readAt: \"seen_at\"`).\n */\nexport type NotificationColumnMap = {\n  /** Recipient FK column. Default: `\"user_id\"`. */\n  recipient?: string;\n  /** Multi-tenant scope column, written from the recipient. Omit → single-tenant. */\n  tenant?: string;\n  /** Read-timestamp column. Present → read-state records \"when\". */\n  readAt?: string;\n  /** Read-flag column (indexed → fast unread filter). Present → read-state is a boolean. */\n  isRead?: string;\n};\n\n/**\n * A `NotificationColumnMap` with the defaults applied. `recipient` is always\n * set, and at least one of `readAt` / `isRead` is always present (the resolver\n * falls back to `readAt`), so consumers never face a \"no read-state\" map.\n */\nexport type ResolvedNotificationColumnMap = {\n  recipient: string;\n  tenant?: string;\n  readAt?: string;\n  isRead?: string;\n};\n\n/** A model class that may carry the `columnMap` static. */\nexport type NotificationColumnMapHost = {\n  columnMap?: NotificationColumnMap;\n};\n\nconst DEFAULT_RECIPIENT_COLUMN = \"user_id\";\nconst DEFAULT_READ_AT_COLUMN = \"read_at\";\n\n/**\n * Resolve a model's declared `columnMap` into a complete map: default the\n * recipient column, and fall back to a `read_at` timestamp when the model\n * declares no read-state column. The fallback guarantees the result always\n * has a usable read-state representation, so no boot-time validation is needed.\n */\nexport function resolveColumnMap(\n  map: NotificationColumnMap | undefined,\n): ResolvedNotificationColumnMap {\n  const recipient = map?.recipient ?? DEFAULT_RECIPIENT_COLUMN;\n  const tenant = map?.tenant;\n\n  if (!map?.readAt && !map?.isRead) {\n    return { recipient, tenant, readAt: DEFAULT_READ_AT_COLUMN };\n  }\n\n  return {\n    recipient,\n    tenant,\n    readAt: map.readAt,\n    isRead: map.isRead,\n  };\n}\n"],"mappings":";AA8DA,MAAM,2BAA2B;AACjC,MAAM,yBAAyB;;;;;;;AAQ/B,SAAgB,iBACd,KAC+B;CAC/B,MAAM,YAAY,KAAK,aAAa;CACpC,MAAM,SAAS,KAAK;CAEpB,IAAI,CAAC,KAAK,UAAU,CAAC,KAAK,QACxB,OAAO;EAAE;EAAW;EAAQ,QAAQ;CAAuB;CAG7D,OAAO;EACL;EACA;EACA,QAAQ,IAAI;EACZ,QAAQ,IAAI;CACd;AACF"}
+{"version":3,"file":"column-map.mjs","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/column-map.ts"],"sourcesContent":["/**\n * `columnMap` — how a notification model's logical roles map to the physical\n * columns of ITS table. The ONE source the model getters, the repository\n * (read filter + write mapping), the database channel, and the migration\n * factory all read, so they can never drift apart.\n *\n * Declared as a `static columnMap` on the model and ejected to userland, so\n * the dev owns it:\n *\n *   @RegisterModel()\n *   export class Notification extends DatabaseNotification {\n *     public static table = \"notifications\";\n *     public static columnMap: NotificationColumnMap = {\n *       tenant: \"organization_id\", // omit → single-tenant\n *       readAt: \"read_at\",         // read-state (see below)\n *     };\n *   }\n *\n * ## Read-state is chosen by which keys are PRESENT\n *\n * - `readAt` only → unread = `read_at IS NULL`; marking read stamps it.\n * - `isRead` only → unread = `is_read = false`; no timestamp.\n * - both        → `is_read` is the indexed flag used for filtering, `read_at`\n *                 records WHEN; marking read sets both.\n *\n * Declare neither and you get the `readAt`-only default — so a model can omit\n * `columnMap` entirely and still work.\n */\n\n/**\n * The logical → physical column bindings a notification model may declare.\n * Every key is optional; `resolveColumnMap` fills the defaults. Values are the\n * app's real column names (rename-friendly: `readAt: \"seen_at\"`).\n */\nexport type NotificationColumnMap = {\n  /** Recipient FK column. Default: `\"user_id\"`. */\n  recipient?: string;\n  /**\n   * Recipient TYPE column (e.g. `\"recipient_type\"`). Declare it to key every\n   * notification by `(type, id)` so identities of different types that share an\n   * id (staff 5 vs customer 5) never read each other's rows. Omit → ids are\n   * the only key (single-identity apps, tables created before the column).\n   */\n  recipientType?: string;\n  /** Multi-tenant scope column, written from the recipient. Omit → single-tenant. */\n  tenant?: string;\n  /** Read-timestamp column. Present → read-state records \"when\". */\n  readAt?: string;\n  /** Read-flag column (indexed → fast unread filter). Present → read-state is a boolean. */\n  isRead?: string;\n};\n\n/**\n * A `NotificationColumnMap` with the defaults applied. `recipient` is always\n * set, and at least one of `readAt` / `isRead` is always present (the resolver\n * falls back to `readAt`), so consumers never face a \"no read-state\" map.\n */\nexport type ResolvedNotificationColumnMap = {\n  recipient: string;\n  recipientType?: string;\n  tenant?: string;\n  readAt?: string;\n  isRead?: string;\n};\n\n/** A model class that may carry the `columnMap` static. */\nexport type NotificationColumnMapHost = {\n  columnMap?: NotificationColumnMap;\n};\n\nconst DEFAULT_RECIPIENT_COLUMN = \"user_id\";\nconst DEFAULT_READ_AT_COLUMN = \"read_at\";\n\n/**\n * Resolve a model's declared `columnMap` into a complete map: default the\n * recipient column, and fall back to a `read_at` timestamp when the model\n * declares no read-state column. The fallback guarantees the result always\n * has a usable read-state representation, so no boot-time validation is needed.\n */\nexport function resolveColumnMap(\n  map: NotificationColumnMap | undefined,\n): ResolvedNotificationColumnMap {\n  const recipient = map?.recipient ?? DEFAULT_RECIPIENT_COLUMN;\n  const tenant = map?.tenant;\n  const recipientType = map?.recipientType;\n\n  if (!map?.readAt && !map?.isRead) {\n    return { recipient, recipientType, tenant, readAt: DEFAULT_READ_AT_COLUMN };\n  }\n\n  return {\n    recipient,\n    recipientType,\n    tenant,\n    readAt: map.readAt,\n    isRead: map.isRead,\n  };\n}\n"],"mappings":";AAsEA,MAAM,2BAA2B;AACjC,MAAM,yBAAyB;;;;;;;AAQ/B,SAAgB,iBACd,KAC+B;CAC/B,MAAM,YAAY,KAAK,aAAa;CACpC,MAAM,SAAS,KAAK;CACpB,MAAM,gBAAgB,KAAK;CAE3B,IAAI,CAAC,KAAK,UAAU,CAAC,KAAK,QACxB,OAAO;EAAE;EAAW;EAAe;EAAQ,QAAQ;CAAuB;CAG5E,OAAO;EACL;EACA;EACA;EACA,QAAQ,IAAI;EACZ,QAAQ,IAAI;CACd;AACF"}

package/esm/in-app/in-app.d.mts

@@ -1,7 +1,8 @@
-import { DatabasePayload, Id, Notifiable } from "../types.mjs";
+import { DatabasePayload, Id } from "../types.mjs";
 import { Channel } from "../contracts/channel.contract.mjs";
 import { NotificationContract } from "../contracts/notification.contract.mjs";
 import "../contracts/index.mjs";
+import { RecipientInput } from "./recipient.mjs";
 import { BaseNotificationsRepository, NotificationModelClass, NotificationsFilter } from "./base-notifications-repository.mjs";
 import "../index.mjs";
 import { TypedRepositoryOptionsWithPages } from "@warlock.js/core";
@@ -33,22 +34,22 @@ declare class InApp {
   configure(options: ConfigureOptions): Channel<DatabasePayload>;
   private get repository();
   /** General list — scoped to recipient; pass `options` for paging + filters. */
-  list(recipient: Notifiable | Id, options?: NotificationsListOptions): Promise<import("@warlock.js/core").PaginationResult<NotificationContract>>;
+  list(recipient: RecipientInput, options?: NotificationsListOptions): Promise<import("@warlock.js/core").PaginationResult<NotificationContract>>;
   /** Unread-only list — common case for badges + dashboards. */
-  listUnread(recipient: Notifiable | Id, options?: NotificationsListOptions): Promise<import("@warlock.js/core").PaginationResult<NotificationContract>>;
+  listUnread(recipient: RecipientInput, options?: NotificationsListOptions): Promise<import("@warlock.js/core").PaginationResult<NotificationContract>>;
   /**
    * Cached unread count — backs the badge. Auto-invalidated by the repo's
    * model create/update events (`RepositoryManager.registerEvents`).
    */
-  countUnread(recipient: Notifiable | Id): Promise<number>;
+  countUnread(recipient: RecipientInput): Promise<number>;
   /** Find one notification for a recipient — for a detail view. */
-  find(recipient: Notifiable | Id, id: Id): Promise<NotificationContract | null>;
+  find(recipient: RecipientInput, id: Id): Promise<NotificationContract | null>;
   /** Mark read — `id` omitted = all unread for this recipient. */
-  markAsRead(recipient: Notifiable | Id, id?: Id): Promise<number>;
+  markAsRead(recipient: RecipientInput, id?: Id): Promise<number>;
   /** Mark unread — same recipient-scoping. */
-  markAsUnread(recipient: Notifiable | Id, id?: Id): Promise<number>;
+  markAsUnread(recipient: RecipientInput, id?: Id): Promise<number>;
   /** Delete/dismiss — `id` omitted = clear all for this recipient. */
-  dismiss(recipient: Notifiable | Id, id?: Id): Promise<number>;
+  dismiss(recipient: RecipientInput, id?: Id): Promise<number>;
 }
 /** Single in-app facade — bound at boot via `inApp.configure(...)`. */
 export declare const inApp: InApp;

package/esm/in-app/in-app.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"in-app.d.mts","names":["_$__0.NotificationContract"],"sources":["../../../../../../../../packages/notifications/src/in-app/in-app.ts"],"mappings":";;;;;;;;;;;;;YA4CY,2BAA2B,gCAAgC;;;;;;YAO3D;EACN,OAAO;EAAwB;;EAC/B,YAAY;EAA6B;;cAKzC;UACI;;;;;EAMD,UAAU,SAAS,mBAAmB,QAAQ;cAQzC;;EAWL,KAAK,WAAW,aAAa,IAAI,UAAU,2BAAwB,mCAAA,iBAAxBA;;EAK3C,WAAW,WAAW,aAAa,IAAI,UAAU,2BAAwB,mCAAA,iBAAxBA;;;;;EAQjD,YAAY,WAAW,aAAa,KAAE;;EAKtC,KAAK,WAAW,aAAa,IAAI,IAAI,KAAE,QAAFA;;EAKrC,WAAW,WAAW,aAAa,IAAI,KAAK,KAAE;;EAK9C,aAAa,WAAW,aAAa,IAAI,KAAK,KAAE;;EAKhD,QAAQ,WAAW,aAAa,IAAI,KAAK,KAAE;;;qBAMvC,OAAK"}
+{"version":3,"file":"in-app.d.mts","names":["_$__0.NotificationContract"],"sources":["../../../../../../../../packages/notifications/src/in-app/in-app.ts"],"mappings":";;;;;;;;;;;;;;YA6CY,2BAA2B,gCAAgC;;;;;;YAO3D;EACN,OAAO;EAAwB;;EAC/B,YAAY;EAA6B;;cAEzC;UACI;;;;;EAMD,UAAU,SAAS,mBAAmB,QAAQ;cAQzC;;EAWL,KAAK,WAAW,gBAAgB,UAAU,2BAAwB,mCAAA,iBAAxBA;;EAK1C,WAAW,WAAW,gBAAgB,UAAU,2BAAwB,mCAAA,iBAAxBA;;;;;EAYhD,YAAY,WAAW,iBAAc;;EAKrC,KAAK,WAAW,gBAAgB,IAAI,KAAE,QAAFA;;EAKpC,WAAW,WAAW,gBAAgB,KAAK,KAAE;;EAK7C,aAAa,WAAW,gBAAgB,KAAK,KAAE;;EAK/C,QAAQ,WAAW,gBAAgB,KAAK,KAAE;;;qBAMtC,OAAK"}

package/esm/in-app/in-app.mjs

@@ -2,7 +2,6 @@ import { databaseChannel } from "../channels/database-channel.mjs";
 import { BaseNotificationsRepository } from "./base-notifications-repository.mjs";
 
 //#region ../../packages/notifications/src/in-app/in-app.ts
-const idOf = (recipient) => typeof recipient === "object" ? recipient.id : recipient;
 var InApp = class {
 	repo;
 	/**
@@ -21,14 +20,14 @@ var InApp = class {
 	list(recipient, options) {
 		return this.repository.list({
 			...options,
-			recipientId: idOf(recipient)
+			...this.repository.scopeOf(recipient)
 		});
 	}
 	/** Unread-only list — common case for badges + dashboards. */
 	listUnread(recipient, options) {
 		return this.repository.list({
 			...options,
-			recipientId: idOf(recipient),
+			...this.repository.scopeOf(recipient),
 			unread: true
 		});
 	}
@@ -38,25 +37,25 @@ var InApp = class {
 	*/
 	countUnread(recipient) {
 		return this.repository.countCached({
-			recipientId: idOf(recipient),
+			...this.repository.scopeOf(recipient),
 			unread: true
 		});
 	}
 	/** Find one notification for a recipient — for a detail view. */
 	find(recipient, id) {
-		return this.repository.findFor(idOf(recipient), id);
+		return this.repository.findFor(recipient, id);
 	}
 	/** Mark read — `id` omitted = all unread for this recipient. */
 	markAsRead(recipient, id) {
-		return this.repository.markRead(idOf(recipient), id);
+		return this.repository.markRead(recipient, id);
 	}
 	/** Mark unread — same recipient-scoping. */
 	markAsUnread(recipient, id) {
-		return this.repository.markUnread(idOf(recipient), id);
+		return this.repository.markUnread(recipient, id);
 	}
 	/** Delete/dismiss — `id` omitted = clear all for this recipient. */
 	dismiss(recipient, id) {
-		return this.repository.deleteFor(idOf(recipient), id);
+		return this.repository.deleteFor(recipient, id);
 	}
 };
 /** Single in-app facade — bound at boot via `inApp.configure(...)`. */

package/esm/in-app/in-app.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"in-app.mjs","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/in-app.ts"],"sourcesContent":["/**\n * `inApp` — app-facing facade for the in-app/database channel.\n *\n * `inApp.configure({ model | repository })` binds the in-app store AND\n * returns the `database` channel — so the read side and the dispatched\n * write side share ONE repository instance.\n *   • `{ model: Notification }`  — 90% case; default repo built internally.\n *   • `{ repository: myRepo }`   — 10% case; custom column mapping / extras.\n *\n * No zero-arg form: the package ships no concrete model/table (thin eject),\n * so the dev MUST tell us which model to use.\n *\n * Every read + mutation is RECIPIENT-SCOPED by construction — `markAsRead(user,\n * id)` cannot flip a row belonging to a different recipient even if handed a\n * foreign id (the recipient id is forced into the filter → 0 rows match).\n *\n * @example\n *   // src/config/notifications.ts:\n *   inApp.configure({ model: Notification }),\n *\n *   // anywhere:\n *   const unread = await inApp.listUnread(user);\n *   const badge  = await inApp.countUnread(user);\n *   const one    = await inApp.find(user, \"ntf_123\");\n *   await inApp.markAsRead(user, \"ntf_123\");\n *   await inApp.markAsRead(user);            // mark ALL unread\n *   await inApp.dismiss(user, \"ntf_123\");    // delete one\n *   await inApp.dismiss(user);               // clear all for this recipient\n */\nimport type { TypedRepositoryOptionsWithPages } from \"@warlock.js/core\";\nimport { databaseChannel } from \"../channels/database-channel\";\nimport type { Channel } from \"../contracts\";\nimport type { DatabasePayload, Id, Notifiable } from \"../types\";\nimport {\n  BaseNotificationsRepository,\n  type NotificationModelClass,\n  type NotificationsFilter,\n} from \"./base-notifications-repository\";\n\n/**\n * List options for the read methods — the repository's paginated options\n * (`page` / `limit` / `orderBy` / filter keys). `recipientId` is always forced\n * from the recipient argument, so passing it here has no effect.\n */\nexport type NotificationsListOptions = TypedRepositoryOptionsWithPages<NotificationsFilter>;\n\n/**\n * Configure options — discriminated so `model` and `repository` are mutually\n * exclusive at the type level. Future knobs (cache / realtime / naming) slot\n * in here without breaking the signature.\n */\nexport type ConfigureOptions =\n  | { model: NotificationModelClass; repository?: never }\n  | { repository: BaseNotificationsRepository; model?: never };\n\nconst idOf = (recipient: Notifiable | Id): Id =>\n  typeof recipient === \"object\" ? recipient.id : recipient;\n\nclass InApp {\n  private repo?: BaseNotificationsRepository;\n\n  /**\n   * Bind the in-app store AND return the `database` channel. Called once\n   * from `config/notifications.ts`. Subsequent calls REPLACE the binding.\n   */\n  public configure(options: ConfigureOptions): Channel<DatabasePayload> {\n    this.repo =\n      \"repository\" in options && options.repository\n        ? options.repository\n        : new BaseNotificationsRepository(options.model);\n    return databaseChannel(this.repo);\n  }\n\n  private get repository(): BaseNotificationsRepository {\n    if (!this.repo) {\n      throw new Error(\n        \"In-app notifications not configured — add \" +\n          \"`database: inApp.configure({ model: Notification })` to config/notifications.ts\",\n      );\n    }\n    return this.repo;\n  }\n\n  /** General list — scoped to recipient; pass `options` for paging + filters. */\n  public list(recipient: Notifiable | Id, options?: NotificationsListOptions) {\n    return this.repository.list({ ...options, recipientId: idOf(recipient) });\n  }\n\n  /** Unread-only list — common case for badges + dashboards. */\n  public listUnread(recipient: Notifiable | Id, options?: NotificationsListOptions) {\n    return this.repository.list({ ...options, recipientId: idOf(recipient), unread: true });\n  }\n\n  /**\n   * Cached unread count — backs the badge. Auto-invalidated by the repo's\n   * model create/update events (`RepositoryManager.registerEvents`).\n   */\n  public countUnread(recipient: Notifiable | Id) {\n    return this.repository.countCached({ recipientId: idOf(recipient), unread: true });\n  }\n\n  /** Find one notification for a recipient — for a detail view. */\n  public find(recipient: Notifiable | Id, id: Id) {\n    return this.repository.findFor(idOf(recipient), id);\n  }\n\n  /** Mark read — `id` omitted = all unread for this recipient. */\n  public markAsRead(recipient: Notifiable | Id, id?: Id) {\n    return this.repository.markRead(idOf(recipient), id);\n  }\n\n  /** Mark unread — same recipient-scoping. */\n  public markAsUnread(recipient: Notifiable | Id, id?: Id) {\n    return this.repository.markUnread(idOf(recipient), id);\n  }\n\n  /** Delete/dismiss — `id` omitted = clear all for this recipient. */\n  public dismiss(recipient: Notifiable | Id, id?: Id) {\n    return this.repository.deleteFor(idOf(recipient), id);\n  }\n}\n\n/** Single in-app facade — bound at boot via `inApp.configure(...)`. */\nexport const inApp = new InApp();\n"],"mappings":";;;;AAuDA,MAAM,QAAQ,cACZ,OAAO,cAAc,WAAW,UAAU,KAAK;AAEjD,IAAM,QAAN,MAAY;CACV,AAAQ;;;;;CAMR,AAAO,UAAU,SAAqD;EACpE,KAAK,OACH,gBAAgB,WAAW,QAAQ,aAC/B,QAAQ,aACR,IAAI,4BAA4B,QAAQ,KAAK;EACnD,OAAO,gBAAgB,KAAK,IAAI;CAClC;CAEA,IAAY,aAA0C;EACpD,IAAI,CAAC,KAAK,MACR,MAAM,IAAI,MACR,2HAEF;EAEF,OAAO,KAAK;CACd;;CAGA,AAAO,KAAK,WAA4B,SAAoC;EAC1E,OAAO,KAAK,WAAW,KAAK;GAAE,GAAG;GAAS,aAAa,KAAK,SAAS;EAAE,CAAC;CAC1E;;CAGA,AAAO,WAAW,WAA4B,SAAoC;EAChF,OAAO,KAAK,WAAW,KAAK;GAAE,GAAG;GAAS,aAAa,KAAK,SAAS;GAAG,QAAQ;EAAK,CAAC;CACxF;;;;;CAMA,AAAO,YAAY,WAA4B;EAC7C,OAAO,KAAK,WAAW,YAAY;GAAE,aAAa,KAAK,SAAS;GAAG,QAAQ;EAAK,CAAC;CACnF;;CAGA,AAAO,KAAK,WAA4B,IAAQ;EAC9C,OAAO,KAAK,WAAW,QAAQ,KAAK,SAAS,GAAG,EAAE;CACpD;;CAGA,AAAO,WAAW,WAA4B,IAAS;EACrD,OAAO,KAAK,WAAW,SAAS,KAAK,SAAS,GAAG,EAAE;CACrD;;CAGA,AAAO,aAAa,WAA4B,IAAS;EACvD,OAAO,KAAK,WAAW,WAAW,KAAK,SAAS,GAAG,EAAE;CACvD;;CAGA,AAAO,QAAQ,WAA4B,IAAS;EAClD,OAAO,KAAK,WAAW,UAAU,KAAK,SAAS,GAAG,EAAE;CACtD;AACF;;AAGA,MAAa,QAAQ,IAAI,MAAM"}
+{"version":3,"file":"in-app.mjs","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/in-app.ts"],"sourcesContent":["/**\n * `inApp` — app-facing facade for the in-app/database channel.\n *\n * `inApp.configure({ model | repository })` binds the in-app store AND\n * returns the `database` channel — so the read side and the dispatched\n * write side share ONE repository instance.\n *   • `{ model: Notification }`  — 90% case; default repo built internally.\n *   • `{ repository: myRepo }`   — 10% case; custom column mapping / extras.\n *\n * No zero-arg form: the package ships no concrete model/table (thin eject),\n * so the dev MUST tell us which model to use.\n *\n * Every read + mutation is RECIPIENT-SCOPED by construction — `markAsRead(user,\n * id)` cannot flip a row belonging to a different recipient even if handed a\n * foreign id (the recipient id is forced into the filter → 0 rows match).\n *\n * @example\n *   // src/config/notifications.ts:\n *   inApp.configure({ model: Notification }),\n *\n *   // anywhere:\n *   const unread = await inApp.listUnread(user);\n *   const badge  = await inApp.countUnread(user);\n *   const one    = await inApp.find(user, \"ntf_123\");\n *   await inApp.markAsRead(user, \"ntf_123\");\n *   await inApp.markAsRead(user);            // mark ALL unread\n *   await inApp.dismiss(user, \"ntf_123\");    // delete one\n *   await inApp.dismiss(user);               // clear all for this recipient\n */\nimport type { TypedRepositoryOptionsWithPages } from \"@warlock.js/core\";\nimport { databaseChannel } from \"../channels/database-channel\";\nimport type { Channel } from \"../contracts\";\nimport type { DatabasePayload, Id } from \"../types\";\nimport {\n  BaseNotificationsRepository,\n  type NotificationModelClass,\n  type NotificationsFilter,\n} from \"./base-notifications-repository\";\nimport type { RecipientInput } from \"./recipient\";\n\n/**\n * List options for the read methods — the repository's paginated options\n * (`page` / `limit` / `orderBy` / filter keys). `recipientId` is always forced\n * from the recipient argument, so passing it here has no effect.\n */\nexport type NotificationsListOptions = TypedRepositoryOptionsWithPages<NotificationsFilter>;\n\n/**\n * Configure options — discriminated so `model` and `repository` are mutually\n * exclusive at the type level. Future knobs (cache / realtime / naming) slot\n * in here without breaking the signature.\n */\nexport type ConfigureOptions =\n  | { model: NotificationModelClass; repository?: never }\n  | { repository: BaseNotificationsRepository; model?: never };\n\nclass InApp {\n  private repo?: BaseNotificationsRepository;\n\n  /**\n   * Bind the in-app store AND return the `database` channel. Called once\n   * from `config/notifications.ts`. Subsequent calls REPLACE the binding.\n   */\n  public configure(options: ConfigureOptions): Channel<DatabasePayload> {\n    this.repo =\n      \"repository\" in options && options.repository\n        ? options.repository\n        : new BaseNotificationsRepository(options.model);\n    return databaseChannel(this.repo);\n  }\n\n  private get repository(): BaseNotificationsRepository {\n    if (!this.repo) {\n      throw new Error(\n        \"In-app notifications not configured — add \" +\n          \"`database: inApp.configure({ model: Notification })` to config/notifications.ts\",\n      );\n    }\n    return this.repo;\n  }\n\n  /** General list — scoped to recipient; pass `options` for paging + filters. */\n  public list(recipient: RecipientInput, options?: NotificationsListOptions) {\n    return this.repository.list({ ...options, ...this.repository.scopeOf(recipient) });\n  }\n\n  /** Unread-only list — common case for badges + dashboards. */\n  public listUnread(recipient: RecipientInput, options?: NotificationsListOptions) {\n    return this.repository.list({\n      ...options,\n      ...this.repository.scopeOf(recipient),\n      unread: true,\n    });\n  }\n\n  /**\n   * Cached unread count — backs the badge. Auto-invalidated by the repo's\n   * model create/update events (`RepositoryManager.registerEvents`).\n   */\n  public countUnread(recipient: RecipientInput) {\n    return this.repository.countCached({ ...this.repository.scopeOf(recipient), unread: true });\n  }\n\n  /** Find one notification for a recipient — for a detail view. */\n  public find(recipient: RecipientInput, id: Id) {\n    return this.repository.findFor(recipient, id);\n  }\n\n  /** Mark read — `id` omitted = all unread for this recipient. */\n  public markAsRead(recipient: RecipientInput, id?: Id) {\n    return this.repository.markRead(recipient, id);\n  }\n\n  /** Mark unread — same recipient-scoping. */\n  public markAsUnread(recipient: RecipientInput, id?: Id) {\n    return this.repository.markUnread(recipient, id);\n  }\n\n  /** Delete/dismiss — `id` omitted = clear all for this recipient. */\n  public dismiss(recipient: RecipientInput, id?: Id) {\n    return this.repository.deleteFor(recipient, id);\n  }\n}\n\n/** Single in-app facade — bound at boot via `inApp.configure(...)`. */\nexport const inApp = new InApp();\n"],"mappings":";;;;AAwDA,IAAM,QAAN,MAAY;CACV,AAAQ;;;;;CAMR,AAAO,UAAU,SAAqD;EACpE,KAAK,OACH,gBAAgB,WAAW,QAAQ,aAC/B,QAAQ,aACR,IAAI,4BAA4B,QAAQ,KAAK;EACnD,OAAO,gBAAgB,KAAK,IAAI;CAClC;CAEA,IAAY,aAA0C;EACpD,IAAI,CAAC,KAAK,MACR,MAAM,IAAI,MACR,2HAEF;EAEF,OAAO,KAAK;CACd;;CAGA,AAAO,KAAK,WAA2B,SAAoC;EACzE,OAAO,KAAK,WAAW,KAAK;GAAE,GAAG;GAAS,GAAG,KAAK,WAAW,QAAQ,SAAS;EAAE,CAAC;CACnF;;CAGA,AAAO,WAAW,WAA2B,SAAoC;EAC/E,OAAO,KAAK,WAAW,KAAK;GAC1B,GAAG;GACH,GAAG,KAAK,WAAW,QAAQ,SAAS;GACpC,QAAQ;EACV,CAAC;CACH;;;;;CAMA,AAAO,YAAY,WAA2B;EAC5C,OAAO,KAAK,WAAW,YAAY;GAAE,GAAG,KAAK,WAAW,QAAQ,SAAS;GAAG,QAAQ;EAAK,CAAC;CAC5F;;CAGA,AAAO,KAAK,WAA2B,IAAQ;EAC7C,OAAO,KAAK,WAAW,QAAQ,WAAW,EAAE;CAC9C;;CAGA,AAAO,WAAW,WAA2B,IAAS;EACpD,OAAO,KAAK,WAAW,SAAS,WAAW,EAAE;CAC/C;;CAGA,AAAO,aAAa,WAA2B,IAAS;EACtD,OAAO,KAAK,WAAW,WAAW,WAAW,EAAE;CACjD;;CAGA,AAAO,QAAQ,WAA2B,IAAS;EACjD,OAAO,KAAK,WAAW,UAAU,WAAW,EAAE;CAChD;AACF;;AAGA,MAAa,QAAQ,IAAI,MAAM"}

package/esm/in-app/index.d.mts

@@ -1,5 +1,6 @@
 import { NotificationColumnMap, NotificationColumnMapHost, ResolvedNotificationColumnMap, resolveColumnMap } from "./column-map.mjs";
 import { DatabaseNotification } from "./database-notification.mjs";
+import { RecipientInput, recipientTypeOf, toRecipientRef } from "./recipient.mjs";
 import { BaseNotificationsRepository, NotificationModelClass, NotificationsFilter } from "./base-notifications-repository.mjs";
 import { ConfigureOptions, NotificationsListOptions, inApp } from "./in-app.mjs";
-export { BaseNotificationsRepository, ConfigureOptions, DatabaseNotification, NotificationColumnMap, NotificationColumnMapHost, NotificationModelClass, NotificationsFilter, NotificationsListOptions, ResolvedNotificationColumnMap, inApp, resolveColumnMap };
+export { BaseNotificationsRepository, ConfigureOptions, DatabaseNotification, NotificationColumnMap, NotificationColumnMapHost, NotificationModelClass, NotificationsFilter, NotificationsListOptions, RecipientInput, ResolvedNotificationColumnMap, inApp, recipientTypeOf, resolveColumnMap, toRecipientRef };

package/esm/in-app/index.mjs

@@ -1,6 +1,7 @@
+import { recipientTypeOf, toRecipientRef } from "./recipient.mjs";
 import { resolveColumnMap } from "./column-map.mjs";
 import { BaseNotificationsRepository } from "./base-notifications-repository.mjs";
 import { DatabaseNotification } from "./database-notification.mjs";
 import { inApp } from "./in-app.mjs";
 
-export { BaseNotificationsRepository, DatabaseNotification, inApp, resolveColumnMap };
+export { BaseNotificationsRepository, DatabaseNotification, inApp, recipientTypeOf, resolveColumnMap, toRecipientRef };

package/esm/in-app/recipient.d.mts

@@ -0,0 +1,17 @@
+import { Id, Notifiable, RecipientRef } from "../types.mjs";
+//#region ../../packages/notifications/src/in-app/recipient.d.ts
+/** What the read and mutation methods accept for "who": a model, a typed ref, or a bare id. */
+export type RecipientInput = Notifiable | RecipientRef | Id;
+/**
+ * The identity type of a recipient model. Auth models name it with `userType`
+ * (the same value the auth config and token payloads use); any other model
+ * falls back to its table name.
+ */
+export declare function recipientTypeOf(notifiable: Notifiable): string;
+/** Normalize any accepted recipient form to `{ id, type? }` (`type` absent for bare ids). */
+export declare function toRecipientRef(recipient: RecipientInput): {
+  id: Id;
+  type?: string;
+};
+//#endregion
+//# sourceMappingURL=recipient.d.mts.map

package/esm/in-app/recipient.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipient.d.mts","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/recipient.ts"],"mappings":";;;YAOY,iBAAiB,aAAa,eAAe;;;;;;wBAOzC,gBAAgB,YAAY;;wBAW5B,eAAe,WAAW;EAAmB,IAAI;EAAI"}

package/esm/in-app/recipient.mjs

@@ -0,0 +1,27 @@
+//#region ../../packages/notifications/src/in-app/recipient.ts
+/**
+* The identity type of a recipient model. Auth models name it with `userType`
+* (the same value the auth config and token payloads use); any other model
+* falls back to its table name.
+*/
+function recipientTypeOf(notifiable) {
+	const userType = notifiable.userType;
+	if (typeof userType === "string" && userType) return userType;
+	return notifiable.constructor.table;
+}
+/** Normalize any accepted recipient form to `{ id, type? }` (`type` absent for bare ids). */
+function toRecipientRef(recipient) {
+	if (typeof recipient !== "object") return { id: recipient };
+	if ("get" in recipient && typeof recipient.get === "function") return {
+		id: recipient.id,
+		type: recipientTypeOf(recipient)
+	};
+	return {
+		id: recipient.id,
+		type: recipient.type
+	};
+}
+
+//#endregion
+export { recipientTypeOf, toRecipientRef };
+//# sourceMappingURL=recipient.mjs.map

package/esm/in-app/recipient.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipient.mjs","names":[],"sources":["../../../../../../../../packages/notifications/src/in-app/recipient.ts"],"sourcesContent":["/**\n * Recipient identity for the in-app store. A recipient is keyed by\n * `(type, id)`: the same id under two identity types is two recipients.\n */\nimport type { Id, Notifiable, RecipientRef } from \"../types\";\n\n/** What the read and mutation methods accept for \"who\": a model, a typed ref, or a bare id. */\nexport type RecipientInput = Notifiable | RecipientRef | Id;\n\n/**\n * The identity type of a recipient model. Auth models name it with `userType`\n * (the same value the auth config and token payloads use); any other model\n * falls back to its table name.\n */\nexport function recipientTypeOf(notifiable: Notifiable): string {\n  const userType = (notifiable as { userType?: unknown }).userType;\n\n  if (typeof userType === \"string\" && userType) {\n    return userType;\n  }\n\n  return (notifiable.constructor as unknown as { table: string }).table;\n}\n\n/** Normalize any accepted recipient form to `{ id, type? }` (`type` absent for bare ids). */\nexport function toRecipientRef(recipient: RecipientInput): { id: Id; type?: string } {\n  if (typeof recipient !== \"object\") {\n    return { id: recipient };\n  }\n\n  if (\"get\" in recipient && typeof recipient.get === \"function\") {\n    return { id: (recipient as Notifiable).id, type: recipientTypeOf(recipient as Notifiable) };\n  }\n\n  return { id: (recipient as RecipientRef).id, type: (recipient as RecipientRef).type };\n}\n"],"mappings":";;;;;;AAcA,SAAgB,gBAAgB,YAAgC;CAC9D,MAAM,WAAY,WAAsC;CAExD,IAAI,OAAO,aAAa,YAAY,UAClC,OAAO;CAGT,OAAQ,WAAW,YAA6C;AAClE;;AAGA,SAAgB,eAAe,WAAsD;CACnF,IAAI,OAAO,cAAc,UACvB,OAAO,EAAE,IAAI,UAAU;CAGzB,IAAI,SAAS,aAAa,OAAO,UAAU,QAAQ,YACjD,OAAO;EAAE,IAAK,UAAyB;EAAI,MAAM,gBAAgB,SAAuB;CAAE;CAG5F,OAAO;EAAE,IAAK,UAA2B;EAAI,MAAO,UAA2B;CAAK;AACtF"}