@classytic/loyalty 0.2.2 → 0.3.0

package/dist/{repositories-CZlhTYVp.mjs → repositories-C_p8asCn.mjs}

@@ -1,7 +1,18 @@
-import { n as createEvent, t as LoyaltyEvents } from "./loyalty-events-Cyt9TwX6.mjs";
+import { n as createEvent, t as LoyaltyEvents } from "./loyalty-events-C38JA3cU.mjs";
 import { Repository, multiTenantPlugin } from "@classytic/mongokit";
 import { randomBytes } from "node:crypto";
+import { throwIfAborted } from "@classytic/repo-core/repository";
 //#region src/domain/errors/base.ts
+/**
+* Base for every loyalty throwable. Implements `HttpError` from
+* `@classytic/repo-core/errors` (the org-canonical throwable contract) so arc
+* catches and serializes them to `ErrorContract` via `toErrorContract()` with
+* the right HTTP `status` and a stable, machine-readable `code`.
+*
+* Codes are hierarchical + lowercase per PACKAGE_RULES ("Errors and wire
+* envelopes"): `loyalty.<entity>.<problem>`. The `status` field (not the old
+* `httpStatus`) is what `HttpError` / arc read — a clean break, no alias.
+*/
 var LoyaltyError = class extends Error {
 	constructor(message) {
 		super(message);
@@ -11,107 +22,147 @@ var LoyaltyError = class extends Error {
 		return {
 			code: this.code,
 			message: this.message,
-			name: this.name
+			name: this.name,
+			status: this.status
 		};
 	}
 };
 //#endregion
 //#region src/domain/errors/domain-errors.ts
 var InsufficientPointsError = class extends LoyaltyError {
-	code = "INSUFFICIENT_POINTS";
-	httpStatus = 400;
+	code = "loyalty.points.insufficient";
+	status = 400;
 	constructor(available, requested) {
 		super(`Insufficient points. Available: ${available}, requested: ${requested}`);
 	}
 };
 var MemberNotFoundError = class extends LoyaltyError {
-	code = "MEMBER_NOT_FOUND";
-	httpStatus = 404;
+	code = "loyalty.member.not_found";
+	status = 404;
 	constructor(id) {
 		super(`Member not found: ${id}`);
 	}
 };
 var MemberAlreadyEnrolledError = class extends LoyaltyError {
-	code = "MEMBER_ALREADY_ENROLLED";
-	httpStatus = 409;
+	code = "loyalty.member.already_enrolled";
+	status = 409;
 	constructor(externalId) {
 		super(`Member already enrolled: ${externalId}`);
 	}
 };
 var MemberInactiveError = class extends LoyaltyError {
-	code = "MEMBER_INACTIVE";
-	httpStatus = 422;
+	code = "loyalty.member.inactive";
+	status = 422;
 	constructor(id) {
 		super(`Member is not active: ${id}`);
 	}
 };
+var RuleNotFoundError = class extends LoyaltyError {
+	code = "loyalty.earning_rule.not_found";
+	status = 404;
+	constructor(id) {
+		super(`Earning rule not found: ${id}`);
+	}
+};
 var TierNotFoundError = class extends LoyaltyError {
-	code = "TIER_NOT_FOUND";
-	httpStatus = 404;
+	code = "loyalty.tier.not_found";
+	status = 404;
 	constructor(id) {
 		super(`Tier not found: ${id}`);
 	}
 };
 var RedemptionNotFoundError = class extends LoyaltyError {
-	code = "REDEMPTION_NOT_FOUND";
-	httpStatus = 404;
+	code = "loyalty.redemption.not_found";
+	status = 404;
 	constructor(id) {
 		super(`Redemption not found: ${id}`);
 	}
 };
 var RedemptionExpiredError = class extends LoyaltyError {
-	code = "REDEMPTION_EXPIRED";
-	httpStatus = 410;
+	code = "loyalty.redemption.expired";
+	status = 410;
 	constructor(id) {
 		super(`Redemption expired: ${id}`);
 	}
 };
 var ReferralNotFoundError = class extends LoyaltyError {
-	code = "REFERRAL_NOT_FOUND";
-	httpStatus = 404;
+	code = "loyalty.referral.not_found";
+	status = 404;
 	constructor(id) {
 		super(`Referral not found: ${id}`);
 	}
 };
 var DuplicateReferralError = class extends LoyaltyError {
-	code = "DUPLICATE_REFERRAL";
-	httpStatus = 409;
+	code = "loyalty.referral.duplicate";
+	status = 409;
 	constructor(refereeId) {
 		super(`Referee already has a referral: ${refereeId}`);
 	}
 };
 var ReferralLimitExceededError = class extends LoyaltyError {
-	code = "REFERRAL_LIMIT_EXCEEDED";
-	httpStatus = 429;
+	code = "loyalty.referral.limit_exceeded";
+	status = 429;
 	constructor(limit, periodDays) {
 		super(`Referral limit of ${limit} per ${periodDays} days exceeded`);
 	}
 };
 var SelfReferralError = class extends LoyaltyError {
-	code = "SELF_REFERRAL";
-	httpStatus = 422;
+	code = "loyalty.referral.self";
+	status = 422;
 	constructor() {
 		super("Cannot refer yourself");
 	}
 };
 var CircularReferralError = class extends LoyaltyError {
-	code = "CIRCULAR_REFERRAL";
-	httpStatus = 422;
+	code = "loyalty.referral.circular";
+	status = 422;
 	constructor() {
 		super("Circular referral detected");
 	}
 };
 var ValidationError = class extends LoyaltyError {
-	code = "VALIDATION_ERROR";
-	httpStatus = 400;
+	code = "loyalty.validation.invalid";
+	status = 400;
 };
 var TenantIsolationError = class extends LoyaltyError {
-	code = "TENANT_ISOLATION";
-	httpStatus = 403;
+	code = "loyalty.tenant.isolation";
+	status = 403;
 	constructor() {
 		super("Tenant context is required but not provided");
 	}
 };
+/**
+* A host passed `ctx.session` (it owns the outer transaction) but did NOT
+* attach a `[PENDING_EVENTS]` queue. Publishing to in-process subscribers
+* BEFORE the host's commit would leak ghost events on rollback, and the
+* outbox save would not be coordinated with the host's unit of work.
+*
+* Two safe patterns: (1) let loyalty own the transaction — call the verb
+* WITHOUT `ctx.session`; or (2) attach a fresh `[PENDING_EVENTS]` array via
+* `{ ...ctx, [PENDING_EVENTS]: queue }` and call `flushPendingLoyaltyEvents`
+* after your transaction commits. Both are exported from the package root.
+*/
+var UnmanagedSessionError = class extends LoyaltyError {
+	code = "loyalty.transaction.unmanaged_session";
+	status = 400;
+	constructor() {
+		super("[loyalty] ctx.session was provided without a PENDING_EVENTS queue. When you own the outer transaction you must also coordinate event publishing — otherwise loyalty would publish to in-process subscribers (and save to the outbox) before your transaction commits, leaking ghost events on rollback. Either call the verb without ctx.session (loyalty owns the unit of work), or attach `{ ...ctx, [PENDING_EVENTS]: queue }` and call `flushPendingLoyaltyEvents(transport, queue)` after your commit. Both `PENDING_EVENTS` and `flushPendingLoyaltyEvents` are exported from `@classytic/loyalty`.");
+	}
+};
+/**
+* The backend doesn't declare the runtime capabilities loyalty's
+* transactional verbs require (earn / adjust / reserve / confirm / release /
+* reverse all run inside `withTransaction`). MongoDB must run as a replica set
+* or sharded cluster. Thrown at engine creation — fail loud at boot, not with
+* a cryptic driver error on the first transactional call.
+*/
+var LoyaltyCapabilityError = class extends LoyaltyError {
+	code = "loyalty.engine.missing_capabilities";
+	status = 500;
+	constructor(missing) {
+		super(`[loyalty] backend missing required capabilities: ${missing.join(", ")}. Point earn / redemption / reversal paths are transactional — MongoDB must run as a replica set or sharded cluster.`);
+	}
+};
 //#endregion
 //#region src/utils/tenant-guard.ts
 /**
@@ -289,8 +340,8 @@ var EarningRuleRepository = class extends Repository {
 				points,
 				description: `Action: ${input.action} (${rule.name})`,
 				referenceType: "action",
-				referenceId: input.referenceId,
-				earningRuleId: rule._id
+				earningRuleId: rule._id,
+				...input.referenceId !== void 0 ? { referenceId: input.referenceId } : {}
 			}, ctx);
 			totalPoints += points;
 			breakdown.push({
@@ -349,15 +400,81 @@ var EarningRuleRepository = class extends Repository {
 };
 //#endregion
 //#region src/events/dispatch.ts
+/**
+* Internal key under which the post-commit event-publish queue is threaded
+* through the context. When set, `dispatchLoyaltyEvent` APPENDS to this queue
+* instead of publishing immediately — the verb that owns the transaction
+* flushes it after commit. A `Symbol.for` so it never collides with
+* host-supplied context fields and never appears in the public type.
+*/
+const PENDING_EVENTS = Symbol.for("@classytic/loyalty:pendingEvents");
 async function dispatchLoyaltyEvent(deps, event, ctx) {
+	const pending = ctx[PENDING_EVENTS];
+	if (ctx.session && !pending) throw new UnmanagedSessionError();
 	if (deps.outbox) try {
 		const saveOptions = {};
 		if (ctx.session !== void 0) saveOptions.session = ctx.session;
 		await deps.outbox.save(event, saveOptions);
-	} catch (_err) {}
+	} catch (err) {
+		deps.logger?.error(`[loyalty] outbox.save failed for ${event.type}:`, err);
+		throw err;
+	}
+	if (pending) {
+		pending.push(event);
+		return;
+	}
 	if (deps.events) try {
 		await deps.events.publish(event);
-	} catch (_err) {}
+	} catch (err) {
+		deps.logger?.error(`[loyalty] events.publish failed for ${event.type}:`, err);
+	}
+}
+/**
+* Runs a multi-write domain verb inside a unit-of-work transaction with the
+* P8 post-commit-publish discipline (PACKAGE_RULES §P8 phased variant):
+*
+*   1. A fresh `[PENDING_EVENTS]` queue is attached to the inner ctx along
+*      with the transaction `session`. Dispatches inside `body` save the
+*      outbox row in-session (atomic with the business write) and queue the
+*      transport publish instead of firing it.
+*   2. The queue is reset at the START of each attempt — a transient-error
+*      retry of `body` can't leak ghost events.
+*   3. After the transaction COMMITS, the queue is flushed to the transport.
+*
+* When the host already owns the outer transaction (`ctx.session` set), it
+* MUST have attached a `[PENDING_EVENTS]` queue — `body` runs directly against
+* the host's session+queue and the host flushes after its own commit. A bare
+* `ctx.session` with no queue throws `UnmanagedSessionError` (raised inside
+* `dispatchLoyaltyEvent` at the first emit).
+*/
+async function runLoyaltyUnit(unitOfWork, deps, ctx, body) {
+	const internalCtx = ctx;
+	if (ctx.session) return body(internalCtx);
+	const pending = [];
+	const result = await unitOfWork.withTransaction(async (session) => {
+		pending.length = 0;
+		return body({
+			...internalCtx,
+			session,
+			[PENDING_EVENTS]: pending
+		});
+	});
+	await flushPendingLoyaltyEvents(deps.events, pending, deps.logger);
+	return result;
+}
+/**
+* Drains a queue of deferred events (the one attached under `[PENDING_EVENTS]`)
+* through the transport, swallowing per-event errors. Called by transactional
+* verbs AFTER `withTransaction` commits, and exported so hosts that own the
+* outer transaction can flush after their own commit.
+*/
+async function flushPendingLoyaltyEvents(events, queue, logger) {
+	if (!events || queue.length === 0) return;
+	for (const event of queue) try {
+		await events.publish(event);
+	} catch (err) {
+		logger?.error(`[loyalty] events.publish failed for ${event.type}:`, err);
+	}
 }
 //#endregion
 //#region src/utils/code-generator.ts
@@ -581,6 +698,12 @@ var PointTransactionRepository = class extends Repository {
 			outbox: this.outbox
 		}, event, ctx);
 	}
+	get _dispatchDeps() {
+		return {
+			events: this.events,
+			outbox: this.outbox
+		};
+	}
 	/**
 	* Auto-inject tenant id from options into doc payload. Matches
 	* `@classytic/order` / `@classytic/promo` — see MemberRepository.
@@ -608,7 +731,9 @@ var PointTransactionRepository = class extends Repository {
 		}
 		const member = await this.memberRepo.requireActiveMember(input.memberId, tc);
 		try {
-			const tx = await this.unitOfWork.withTransaction(async (session) => {
+			let payload;
+			const tx = await runLoyaltyUnit(this.unitOfWork, this._dispatchDeps, ctx, async (txCtx) => {
+				const session = txCtx.session;
 				if (input.idempotencyKey) {
 					const dup = await this.getByQuery({ idempotencyKey: input.idempotencyKey }, {
 						throwOnNotFound: false,
@@ -638,26 +763,27 @@ var PointTransactionRepository = class extends Repository {
 					...input.metadata ? { metadata: input.metadata } : {}
 				};
 				if (input.idempotencyKey) data.idempotencyKey = input.idempotencyKey;
-				return this.create(data, {
+				const created = await this.create(data, {
 					session,
 					...tc
 				});
+				payload = {
+					memberId: member._id,
+					externalId: member.externalId,
+					externalType: member.externalType,
+					points: input.points,
+					balanceAfter: created.balanceAfter,
+					transactionId: created._id,
+					referenceType: input.referenceType,
+					referenceId: input.referenceId
+				};
+				await this._dispatch(createEvent(LoyaltyEvents.POINTS_EARNED, payload, txCtx, {
+					resource: "pointTransaction",
+					resourceId: created._id
+				}), txCtx);
+				return created;
 			});
-			const payload = {
-				memberId: member._id,
-				externalId: member.externalId,
-				externalType: member.externalType,
-				points: input.points,
-				balanceAfter: tx.balanceAfter,
-				transactionId: tx._id,
-				referenceType: input.referenceType,
-				referenceId: input.referenceId
-			};
-			await this._dispatch(createEvent(LoyaltyEvents.POINTS_EARNED, payload, ctx, {
-				resource: "pointTransaction",
-				resourceId: tx._id
-			}), ctx);
-			this.notifications?.notify(LoyaltyEvents.POINTS_EARNED, { ...payload });
+			if (payload) this.notifications?.notify(LoyaltyEvents.POINTS_EARNED, { ...payload });
 			return tx;
 		} catch (err) {
 			if (input.idempotencyKey && (isDuplicateKey(err) || isWriteConflict(err))) {
@@ -691,6 +817,7 @@ var PointTransactionRepository = class extends Repository {
 		let totalPoints = 0;
 		const errors = [];
 		for (const row of members) {
+			throwIfAborted(ctx.signal);
 			try {
 				validatePositivePoints(row.points);
 			} catch (err) {
@@ -765,7 +892,9 @@ var PointTransactionRepository = class extends Repository {
 		}
 		const member = await this.memberRepo.requireActiveMember(input.memberId, tc);
 		if (input.points < 0 && member.balance.current < Math.abs(input.points)) throw new InsufficientPointsError(member.balance.current, Math.abs(input.points));
-		const tx = await this.unitOfWork.withTransaction(async (session) => {
+		let payload;
+		const tx = await runLoyaltyUnit(this.unitOfWork, this._dispatchDeps, ctx, async (txCtx) => {
+			const session = txCtx.session;
 			if (input.idempotencyKey) {
 				const dup = await this.getByQuery({ idempotencyKey: input.idempotencyKey }, {
 					throwOnNotFound: false,
@@ -796,24 +925,25 @@ var PointTransactionRepository = class extends Repository {
 				actorId: ctx.actorId
 			};
 			if (input.idempotencyKey) data.idempotencyKey = input.idempotencyKey;
-			return this.create(data, {
+			const created = await this.create(data, {
 				session,
 				...tc
 			});
+			payload = {
+				memberId: member._id,
+				externalId: member.externalId,
+				points: input.points,
+				balanceAfter: created.balanceAfter,
+				transactionId: created._id,
+				description: input.description
+			};
+			await this._dispatch(createEvent(LoyaltyEvents.POINTS_ADJUSTED, payload, txCtx, {
+				resource: "pointTransaction",
+				resourceId: created._id
+			}), txCtx);
+			return created;
 		});
-		const payload = {
-			memberId: member._id,
-			externalId: member.externalId,
-			points: input.points,
-			balanceAfter: tx.balanceAfter,
-			transactionId: tx._id,
-			description: input.description
-		};
-		await this._dispatch(createEvent(LoyaltyEvents.POINTS_ADJUSTED, payload, ctx, {
-			resource: "pointTransaction",
-			resourceId: tx._id
-		}), ctx);
-		this.notifications?.notify(LoyaltyEvents.POINTS_ADJUSTED, { ...payload });
+		if (payload) this.notifications?.notify(LoyaltyEvents.POINTS_ADJUSTED, { ...payload });
 		return tx;
 	}
 	async processExpirations(ctx) {
@@ -833,6 +963,7 @@ var PointTransactionRepository = class extends Repository {
 		let transactionCount = 0;
 		const affectedMemberIds = /* @__PURE__ */ new Set();
 		for (const tx of expiredTxs) {
+			throwIfAborted(ctx.signal);
 			await this.unitOfWork.withTransaction(async (session) => {
 				await this.create({
 					memberId: tx.memberId,
@@ -931,6 +1062,12 @@ var RedemptionRepository = class extends Repository {
 			outbox: this.outbox
 		}, event, ctx);
 	}
+	get _dispatchDeps() {
+		return {
+			events: this.events,
+			outbox: this.outbox
+		};
+	}
 	/**
 	* Atomic compare-and-set status transition.
 	* Returns null if the current status doesn't match `expectedStatus` (CAS mismatch).
@@ -1000,7 +1137,9 @@ var RedemptionRepository = class extends Repository {
 		if (!validation.valid) throw new ValidationError(validation.error ?? "Redemption validation failed");
 		const member = await this.memberRepo.requireActiveMember(input.memberId, tc);
 		const expiresAt = input.expiresAt ?? new Date(Date.now() + this.config.redemption.reservationTtlMinutes * 60 * 1e3);
-		const redemption = await this.unitOfWork.withTransaction(async (session) => {
+		let payload;
+		const redemption = await runLoyaltyUnit(this.unitOfWork, this._dispatchDeps, ctx, async (txCtx) => {
+			const session = txCtx.session;
 			const updatedMember = await this.memberRepo.updateBalance(input.memberId, { current: -validation.pointsToRedeem }, {
 				session,
 				...tc
@@ -1018,25 +1157,26 @@ var RedemptionRepository = class extends Repository {
 				ownerId: input.ownerId,
 				expiresAt
 			};
-			return this.create(data, {
+			const created = await this.create(data, {
 				session,
 				...tc
 			});
+			payload = {
+				memberId: member._id,
+				externalId: member.externalId,
+				redemptionId: created._id,
+				points: validation.pointsToRedeem,
+				discountAmount: validation.discountAmount,
+				ownerType: input.ownerType,
+				ownerId: input.ownerId
+			};
+			await this._dispatch(createEvent(LoyaltyEvents.REDEMPTION_RESERVED, payload, txCtx, {
+				resource: "redemption",
+				resourceId: created._id
+			}), txCtx);
+			return created;
 		});
-		const payload = {
-			memberId: member._id,
-			externalId: member.externalId,
-			redemptionId: redemption._id,
-			points: validation.pointsToRedeem,
-			discountAmount: validation.discountAmount,
-			ownerType: input.ownerType,
-			ownerId: input.ownerId
-		};
-		await this._dispatch(createEvent(LoyaltyEvents.REDEMPTION_RESERVED, payload, ctx, {
-			resource: "redemption",
-			resourceId: redemption._id
-		}), ctx);
-		this.notifications?.notify(LoyaltyEvents.REDEMPTION_RESERVED, { ...payload });
+		if (payload) this.notifications?.notify(LoyaltyEvents.REDEMPTION_RESERVED, { ...payload });
 		return redemption;
 	}
 	async confirm(redemptionId, ctx) {
@@ -1049,7 +1189,9 @@ var RedemptionRepository = class extends Repository {
 		});
 		if (!redemption) throw new RedemptionNotFoundError(redemptionId);
 		if (redemption.expiresAt && redemption.expiresAt < /* @__PURE__ */ new Date()) throw new RedemptionExpiredError(redemptionId);
-		const updated = await this.unitOfWork.withTransaction(async (session) => {
+		let payload;
+		const updated = await runLoyaltyUnit(this.unitOfWork, this._dispatchDeps, ctx, async (txCtx) => {
+			const session = txCtx.session;
 			if (!await this.atomicStatusTransition(redemptionId, "reserved", {
 				status: "confirmed",
 				pointsConfirmed: redemption.pointsReserved,
@@ -1058,7 +1200,10 @@ var RedemptionRepository = class extends Repository {
 				session,
 				...tc
 			})) throw new ValidationError(`Redemption status must be 'reserved', got '${redemption.status}'`);
-			const member = await this.memberRepo.requireActiveMember(redemption.memberId, tc);
+			const member = await this.memberRepo.requireActiveMember(redemption.memberId, {
+				session,
+				...tc
+			});
 			const tx = await this.txRepo.create({
 				memberId: redemption.memberId,
 				programId: member.programId,
@@ -1084,26 +1229,22 @@ var RedemptionRepository = class extends Repository {
 				...tc
 			});
 			if (!confirmed) throw new RedemptionNotFoundError(redemptionId);
+			payload = {
+				memberId: confirmed.memberId,
+				externalId: member.externalId,
+				redemptionId: confirmed._id,
+				points: confirmed.pointsConfirmed,
+				discountAmount: confirmed.discountAmount,
+				ownerType: confirmed.ownerType,
+				ownerId: confirmed.ownerId
+			};
+			await this._dispatch(createEvent(LoyaltyEvents.REDEMPTION_CONFIRMED, payload, txCtx, {
+				resource: "redemption",
+				resourceId: confirmed._id
+			}), txCtx);
 			return confirmed;
 		});
-		const member = await this.memberRepo.getById(updated.memberId, {
-			throwOnNotFound: false,
-			...tc
-		});
-		const payload = {
-			memberId: updated.memberId,
-			externalId: member?.externalId ?? "",
-			redemptionId: updated._id,
-			points: updated.pointsConfirmed,
-			discountAmount: updated.discountAmount,
-			ownerType: updated.ownerType,
-			ownerId: updated.ownerId
-		};
-		await this._dispatch(createEvent(LoyaltyEvents.REDEMPTION_CONFIRMED, payload, ctx, {
-			resource: "redemption",
-			resourceId: updated._id
-		}), ctx);
-		this.notifications?.notify(LoyaltyEvents.REDEMPTION_CONFIRMED, { ...payload });
+		if (payload) this.notifications?.notify(LoyaltyEvents.REDEMPTION_CONFIRMED, { ...payload });
 		return updated;
 	}
 	async release(redemptionId, ctx) {
@@ -1115,7 +1256,9 @@ var RedemptionRepository = class extends Repository {
 			...tc
 		});
 		if (!redemption) throw new RedemptionNotFoundError(redemptionId);
-		const updated = await this.unitOfWork.withTransaction(async (session) => {
+		let payload;
+		const updated = await runLoyaltyUnit(this.unitOfWork, this._dispatchDeps, ctx, async (txCtx) => {
+			const session = txCtx.session;
 			const transitioned = await this.atomicStatusTransition(redemptionId, "reserved", {
 				status: "released",
 				releasedAt: /* @__PURE__ */ new Date()
@@ -1128,26 +1271,27 @@ var RedemptionRepository = class extends Repository {
 				session,
 				...tc
 			});
+			const member = await this.memberRepo.getById(transitioned.memberId, {
+				throwOnNotFound: false,
+				session,
+				...tc
+			});
+			payload = {
+				memberId: transitioned.memberId,
+				externalId: member?.externalId ?? "",
+				redemptionId: transitioned._id,
+				points: transitioned.pointsReserved,
+				discountAmount: transitioned.discountAmount,
+				ownerType: transitioned.ownerType,
+				ownerId: transitioned.ownerId
+			};
+			await this._dispatch(createEvent(LoyaltyEvents.REDEMPTION_RELEASED, payload, txCtx, {
+				resource: "redemption",
+				resourceId: transitioned._id
+			}), txCtx);
 			return transitioned;
 		});
-		const member = await this.memberRepo.getById(updated.memberId, {
-			throwOnNotFound: false,
-			...tc
-		});
-		const payload = {
-			memberId: updated.memberId,
-			externalId: member?.externalId ?? "",
-			redemptionId: updated._id,
-			points: updated.pointsReserved,
-			discountAmount: updated.discountAmount,
-			ownerType: updated.ownerType,
-			ownerId: updated.ownerId
-		};
-		await this._dispatch(createEvent(LoyaltyEvents.REDEMPTION_RELEASED, payload, ctx, {
-			resource: "redemption",
-			resourceId: updated._id
-		}), ctx);
-		this.notifications?.notify(LoyaltyEvents.REDEMPTION_RELEASED, { ...payload });
+		if (payload) this.notifications?.notify(LoyaltyEvents.REDEMPTION_RELEASED, { ...payload });
 		return updated;
 	}
 	/**
@@ -1188,7 +1332,9 @@ var RedemptionRepository = class extends Repository {
 				usedProportional = true;
 			} else proportionalFallback = true;
 		}
-		const reversed = await this.unitOfWork.withTransaction(async (session) => {
+		let payload;
+		const reversed = await runLoyaltyUnit(this.unitOfWork, this._dispatchDeps, ctx, async (txCtx) => {
+			const session = txCtx.session;
 			const transitioned = await this.atomicStatusTransition(redemptionId, "confirmed", {
 				status: "reversed",
 				reversedAt: /* @__PURE__ */ new Date(),
@@ -1198,9 +1344,12 @@ var RedemptionRepository = class extends Repository {
 				...tc
 			});
 			if (!transitioned) throw new ValidationError(`Redemption status must be 'confirmed', got '${redemption.status}'`);
+			const member = await this.memberRepo.requireMember(redemption.memberId, {
+				session,
+				...tc
+			});
 			let creditTxId = "";
 			if (pointsToCredit > 0) {
-				const member = await this.memberRepo.requireMember(redemption.memberId, tc);
 				const updatedMember = await this.memberRepo.updateBalance(redemption.memberId, {
 					current: pointsToCredit,
 					redeemed: -pointsToCredit
@@ -1233,6 +1382,7 @@ var RedemptionRepository = class extends Repository {
 			}
 			const finalUpdate = {};
 			if (creditTxId) finalUpdate.reversalTransactionId = creditTxId;
+			let result = transitioned;
 			if (Object.keys(finalUpdate).length > 0) {
 				const updated = await this.update(redemptionId, finalUpdate, {
 					throwOnNotFound: true,
@@ -1241,29 +1391,25 @@ var RedemptionRepository = class extends Repository {
 					...tc
 				});
 				if (!updated) throw new RedemptionNotFoundError(redemptionId);
-				return updated;
+				result = updated;
 			}
-			return transitioned;
-		});
-		const member = await this.memberRepo.getById(reversed.memberId, {
-			throwOnNotFound: false,
-			...tc
+			payload = {
+				memberId: result.memberId,
+				externalId: member.externalId,
+				redemptionId: result._id,
+				pointsCredited: pointsToCredit,
+				originalPoints,
+				proportional: usedProportional,
+				transactionId: result.reversalTransactionId ?? ""
+			};
+			if (options?.reason) payload.reason = options.reason;
+			await this._dispatch(createEvent(LoyaltyEvents.REDEMPTION_REVERSED, payload, txCtx, {
+				resource: "redemption",
+				resourceId: result._id
+			}), txCtx);
+			return result;
 		});
-		const payload = {
-			memberId: reversed.memberId,
-			externalId: member?.externalId ?? "",
-			redemptionId: reversed._id,
-			pointsCredited: pointsToCredit,
-			originalPoints,
-			proportional: usedProportional,
-			transactionId: reversed.reversalTransactionId ?? ""
-		};
-		if (options?.reason) payload.reason = options.reason;
-		await this._dispatch(createEvent(LoyaltyEvents.REDEMPTION_REVERSED, payload, ctx, {
-			resource: "redemption",
-			resourceId: reversed._id
-		}), ctx);
-		this.notifications?.notify(LoyaltyEvents.REDEMPTION_REVERSED, { ...payload });
+		if (payload) this.notifications?.notify(LoyaltyEvents.REDEMPTION_REVERSED, { ...payload });
 		return reversed;
 	}
 	async cleanupExpired(ctx) {
@@ -1277,6 +1423,7 @@ var RedemptionRepository = class extends Repository {
 		}, tc);
 		let released = 0;
 		for (const redemption of expired) {
+			throwIfAborted(ctx.signal);
 			await this.release(redemption._id, ctx);
 			released++;
 		}
@@ -1478,6 +1625,7 @@ var ReferralRepository = class extends Repository {
 		}, tc);
 		let count = 0;
 		for (const referral of expired) {
+			throwIfAborted(ctx.signal);
 			await this.update(referral._id, { status: "expired" }, tc);
 			count++;
 		}
@@ -1652,16 +1800,19 @@ var TierDefinitionRepository = class extends Repository {
 		let upgraded = 0;
 		let downgraded = 0;
 		let unchanged = 0;
-		for (const member of members) switch ((await this.evaluateMember(member._id, ctx)).action) {
-			case "upgraded":
-				upgraded++;
-				break;
-			case "downgraded":
-				downgraded++;
-				break;
-			default:
-				unchanged++;
-				break;
+		for (const member of members) {
+			throwIfAborted(ctx.signal);
+			switch ((await this.evaluateMember(member._id, ctx)).action) {
+				case "upgraded":
+					upgraded++;
+					break;
+				case "downgraded":
+					downgraded++;
+					break;
+				default:
+					unchanged++;
+					break;
+			}
 		}
 		return {
 			upgraded,
@@ -1740,6 +1891,7 @@ var TierDefinitionRepository = class extends Repository {
 		}, tc);
 		let cleared = 0;
 		for (const member of expired) {
+			throwIfAborted(ctx.signal);
 			const previousOverride = member.tierOverride;
 			if (!previousOverride) continue;
 			await this.memberRepo.update(member._id, {
@@ -1924,4 +2076,4 @@ function createRepositories(input) {
 	};
 }
 //#endregion
-export { PointTransactionRepository as a, ValidationError as c, RedemptionRepository as i, TierDefinitionRepository as n, MemberRepository as o, ReferralRepository as r, EarningRuleRepository as s, createRepositories as t };
+export { TenantIsolationError as C, ValidationError as E, SelfReferralError as S, UnmanagedSessionError as T, RedemptionExpiredError as _, PointTransactionRepository as a, ReferralNotFoundError as b, flushPendingLoyaltyEvents as c, DuplicateReferralError as d, InsufficientPointsError as f, MemberNotFoundError as g, MemberInactiveError as h, RedemptionRepository as i, EarningRuleRepository as l, MemberAlreadyEnrolledError as m, TierDefinitionRepository as n, MemberRepository as o, LoyaltyCapabilityError as p, ReferralRepository as r, PENDING_EVENTS as s, createRepositories as t, CircularReferralError as u, RedemptionNotFoundError as v, TierNotFoundError as w, RuleNotFoundError as x, ReferralLimitExceededError as y };