@classytic/revenue 1.1.4 → 2.0.1

package/dist/settlement.repository-DHIPx5S4.mjs

@@ -0,0 +1,771 @@
+import { n as createEvent, t as REVENUE_EVENTS } from "./event-constants-CEMitnIV.mjs";
+import { F as TRANSACTION_STATUS, g as SETTLEMENT_STATUS, r as SUBSCRIPTION_STATUS, w as HOLD_STATUS } from "./subscription.enums-tfoAgsTv.mjs";
+import { d as SubscriptionNotFoundError, f as TransactionNotFoundError, p as ValidationError, u as SettlementNotFoundError } from "./errors-DHa8JVQ-.mjs";
+import { SETTLEMENT_STATE_MACHINE, SUBSCRIPTION_STATE_MACHINE, TRANSACTION_STATE_MACHINE } from "./core/state-machines.mjs";
+import { a as reverseTax, c as reverseCommission, n as calculateSplits, s as calculateCommission, t as calculateOrganizationPayout } from "./splits-BAfY-a9P.mjs";
+import { Repository, withTransaction } from "@classytic/mongokit";
+
+//#region src/repositories/transaction.repository.ts
+/**
+* TransactionRepository — extends mongokit Repository.
+*
+* CRUD inherited: getAll, getById, getByQuery, create, update, delete, count, exists.
+* Domain verbs: createPaymentIntent, verify, refund, handleWebhook, hold, release, split.
+*
+* All domain verbs return raw mongokit docs — no custom envelopes.
+* Composite results (refund creates a new doc) are stored in metadata on the primary doc.
+*/
+var TransactionRepository = class extends Repository {
+	deps;
+	constructor(model, plugins = []) {
+		super(model, plugins);
+	}
+	inject(deps) {
+		this.deps = deps;
+	}
+	/**
+	* Thread `ctx.organizationId` (and future ctx fields) into mongokit
+	* options so the `multiTenantPlugin` can auto-scope filters, queries,
+	* and inserts. Merges any caller-supplied extras. Centralizing this
+	* here means every domain verb participates in scope isolation without
+	* per-call boilerplate.
+	*/
+	optsFromCtx(ctx, extra = {}) {
+		const out = { ...extra };
+		if (ctx.organizationId !== void 0) out.organizationId = ctx.organizationId;
+		if (ctx.session !== void 0) out.session = ctx.session;
+		return out;
+	}
+	/**
+	* Save an event to the host-owned outbox, session-bound when available.
+	*
+	* When `session` is passed, the outbox row commits atomically with the
+	* business write (P8 true session-bound write). When absent, the save
+	* happens after commit — still durable via the host's relay, but with a
+	* small at-most-once window on process crash.
+	*
+	* Isolated try/catch: an outbox failure never throws out of this helper;
+	* the caller still issues a transport.publish.
+	*/
+	async saveToOutbox(event, session) {
+		if (!this.deps.outbox) return;
+		try {
+			await this.deps.outbox.save(event, session !== void 0 ? { session } : {});
+		} catch (err) {
+			this.deps.logger?.error("[revenue] outbox.save failed for", event.type, err);
+		}
+	}
+	/**
+	* Publish an event to the in-process `EventTransport` after commit.
+	* Transport failure is logged — the host relay will still redeliver from
+	* the outbox, so in-process subscribers missing an event is recoverable.
+	*/
+	async publishToTransport(event) {
+		try {
+			await this.deps.events.publish(event);
+		} catch (err) {
+			this.deps.logger?.error("[revenue] events.publish failed for", event.type, err);
+		}
+	}
+	/**
+	* Non-transactional dispatch (used by verbs that don't open their own
+	* `withTransaction` block): outbox.save (session-bound when ctx provides
+	* one) → transport.publish. Matches arc's EventOutbox + MemoryEventTransport
+	* wiring bit-for-bit.
+	*/
+	async dispatch(event, ctx = {}) {
+		await this.saveToOutbox(event, ctx.session);
+		await this.publishToTransport(event);
+	}
+	/** Creates transaction + calls provider. Returns the created transaction doc. */
+	async createPaymentIntent(params, ctx = {}) {
+		const currency = params.currency ?? this.deps.defaultCurrency;
+		const provider = this.deps.providers.get(params.gateway);
+		if (params.idempotencyKey) {
+			const existing = await this.getByQuery({ idempotencyKey: params.idempotencyKey }, this.optsFromCtx(ctx, { throwOnNotFound: false }));
+			if (existing) return existing;
+		}
+		const commissionRate = this.deps.commission?.defaultRate ?? 0;
+		const gatewayFeeRate = this.deps.commission?.gatewayFeeRate ?? 0;
+		const commission = calculateCommission(params.amount, commissionRate, gatewayFeeRate);
+		let gatewayData = { type: params.gateway };
+		if (params.amount > 0) {
+			const intent = await provider.createIntent({
+				amount: params.amount,
+				currency,
+				metadata: params.metadata,
+				...params.paymentData
+			});
+			gatewayData = {
+				type: params.gateway,
+				sessionId: intent.sessionId,
+				paymentIntentId: intent.paymentIntentId ?? intent.id,
+				metadata: {
+					clientSecret: intent.clientSecret,
+					paymentUrl: intent.paymentUrl,
+					instructions: intent.instructions
+				}
+			};
+		}
+		const transaction = await this.create({
+			organizationId: ctx.organizationId,
+			customerId: params.data?.customerId ?? null,
+			type: params.monetizationType === "subscription" ? "subscription" : "purchase",
+			flow: "inflow",
+			tags: params.monetizationType ? [params.monetizationType] : [],
+			amount: params.amount,
+			currency,
+			fee: commission?.gatewayFeeAmount ?? 0,
+			tax: 0,
+			net: params.amount - (commission?.gatewayFeeAmount ?? 0),
+			method: params.gateway,
+			status: params.amount === 0 ? TRANSACTION_STATUS.VERIFIED : TRANSACTION_STATUS.PENDING,
+			gateway: gatewayData,
+			commission: commission ?? void 0,
+			sourceId: params.data?.sourceId,
+			sourceModel: params.data?.sourceModel,
+			idempotencyKey: params.idempotencyKey,
+			metadata: params.metadata
+		}, this.optsFromCtx(ctx));
+		await this.dispatch(createEvent(REVENUE_EVENTS.MONETIZATION_CREATED, {
+			monetizationType: params.monetizationType,
+			transaction
+		}, ctx, {
+			resource: "transaction",
+			resourceId: transaction.publicId
+		}), ctx);
+		return transaction;
+	}
+	/** Verifies payment via provider, updates status. Returns the updated doc. */
+	async verify(paymentIntentId, options = {}, ctx = {}) {
+		const readOpts = this.optsFromCtx(ctx, { throwOnNotFound: false });
+		let transaction = await this.getByQuery({ "gateway.sessionId": paymentIntentId }, readOpts);
+		if (!transaction) transaction = await this.getByQuery({ "gateway.paymentIntentId": paymentIntentId }, readOpts);
+		if (!transaction) transaction = await this.getById(paymentIntentId, readOpts);
+		if (!transaction) throw new TransactionNotFoundError(paymentIntentId);
+		const provider = this.deps.providers.get(transaction.method);
+		const intentId = transaction.gateway?.paymentIntentId ?? transaction.gateway?.sessionId ?? paymentIntentId;
+		const paymentResult = await provider.verifyPayment(intentId);
+		let newStatus;
+		if (paymentResult.status === "succeeded") newStatus = TRANSACTION_STATUS.VERIFIED;
+		else if (paymentResult.status === "failed") newStatus = TRANSACTION_STATUS.FAILED;
+		else if (paymentResult.status === "requires_action") newStatus = TRANSACTION_STATUS.REQUIRES_ACTION;
+		else newStatus = TRANSACTION_STATUS.PROCESSING;
+		TRANSACTION_STATE_MACHINE.validate(transaction.status, newStatus, String(transaction._id));
+		const updates = { status: newStatus };
+		if (newStatus === TRANSACTION_STATUS.VERIFIED) {
+			updates.verifiedAt = /* @__PURE__ */ new Date();
+			updates.verifiedBy = options.verifiedBy;
+		} else if (newStatus === TRANSACTION_STATUS.FAILED) {
+			updates.failedAt = /* @__PURE__ */ new Date();
+			updates.failureReason = "Payment verification failed";
+		}
+		const updated = await this.update(transaction._id, updates, this.optsFromCtx(ctx));
+		if (newStatus === TRANSACTION_STATUS.VERIFIED) {
+			await this.deps.bridges.ledger?.onPaymentVerified?.(updated, ctx);
+			await this.deps.bridges.notification?.onPaymentVerified?.(updated, ctx);
+		}
+		const eventName = newStatus === TRANSACTION_STATUS.VERIFIED ? REVENUE_EVENTS.PAYMENT_VERIFIED : newStatus === TRANSACTION_STATUS.FAILED ? REVENUE_EVENTS.PAYMENT_FAILED : newStatus === TRANSACTION_STATUS.REQUIRES_ACTION ? REVENUE_EVENTS.PAYMENT_REQUIRES_ACTION : REVENUE_EVENTS.PAYMENT_PROCESSING;
+		await this.dispatch(createEvent(eventName, {
+			transaction: updated,
+			paymentResult,
+			verifiedBy: options.verifiedBy
+		}, ctx, {
+			resource: "transaction",
+			resourceId: updated?.publicId
+		}), ctx);
+		return updated;
+	}
+	/**
+	* Creates refund transaction, updates original. Returns the refund transaction doc.
+	*
+	* The provider call happens OUTSIDE the transaction — it's a non-idempotent external
+	* side effect we can't roll back. The two Mongo writes (create refund + update original)
+	* run inside `withTransaction` so they commit atomically or both abort. Bridges and
+	* event emission run AFTER commit because they're independent side effects; rolling
+	* them back would not undo external state anyway.
+	*
+	* Powered by mongokit 3.6's module-level `withTransaction` helper. Automatically
+	* retries on `TransientTransactionError` / `UnknownTransactionCommitResult`.
+	*/
+	async refund(transactionId, amount, options = {}, ctx = {}) {
+		const transaction = await this.getById(transactionId, this.optsFromCtx(ctx));
+		if (!transaction) throw new TransactionNotFoundError(transactionId);
+		const refundAmount = amount ?? transaction.amount;
+		const existingRefunded = transaction.refundedAmount ?? 0;
+		const isPartialRefund = existingRefunded + refundAmount < transaction.amount;
+		const newStatus = isPartialRefund ? TRANSACTION_STATUS.PARTIALLY_REFUNDED : TRANSACTION_STATUS.REFUNDED;
+		TRANSACTION_STATE_MACHINE.validate(transaction.status, newStatus, transactionId);
+		const provider = this.deps.providers.get(transaction.method);
+		const paymentId = transaction.gateway?.paymentIntentId ?? transaction.gateway?.sessionId ?? transactionId;
+		await provider.refund(paymentId, refundAmount, { reason: options.reason });
+		const reversedCommission = reverseCommission(transaction.commission, transaction.amount, refundAmount);
+		const reversedTax = transaction.tax ? reverseTax({
+			isApplicable: true,
+			rate: 0,
+			baseAmount: transaction.amount,
+			taxAmount: transaction.tax,
+			totalAmount: transaction.amount + transaction.tax,
+			pricesIncludeTax: false
+		}, transaction.amount, refundAmount) : void 0;
+		const pendingEvents = [];
+		const refundTransaction = await withTransaction(this.Model.db, async (session) => {
+			const writeOpts = this.optsFromCtx(ctx, { session });
+			const refundTxn = await this.create({
+				organizationId: transaction.organizationId,
+				customerId: transaction.customerId,
+				type: "refund",
+				flow: "outflow",
+				tags: ["refund"],
+				amount: refundAmount,
+				currency: transaction.currency,
+				fee: reversedCommission?.gatewayFeeAmount ?? 0,
+				tax: reversedTax?.taxAmount ?? 0,
+				net: refundAmount - (reversedCommission?.gatewayFeeAmount ?? 0) - (reversedTax?.taxAmount ?? 0),
+				method: transaction.method,
+				status: TRANSACTION_STATUS.VERIFIED,
+				gateway: transaction.gateway,
+				commission: reversedCommission ?? void 0,
+				relatedTransactionId: transaction._id,
+				sourceId: transaction.sourceId,
+				sourceModel: transaction.sourceModel,
+				verifiedAt: /* @__PURE__ */ new Date(),
+				metadata: { reason: options.reason }
+			}, writeOpts);
+			await this.update(transactionId, {
+				status: newStatus,
+				refundedAmount: existingRefunded + refundAmount,
+				refundedAt: /* @__PURE__ */ new Date()
+			}, writeOpts);
+			const event = createEvent(REVENUE_EVENTS.PAYMENT_REFUNDED, {
+				transaction,
+				refundTransaction: refundTxn,
+				refundAmount,
+				reason: options.reason,
+				isPartialRefund
+			}, ctx, {
+				resource: "transaction",
+				resourceId: transaction.publicId
+			});
+			await this.saveToOutbox(event, session);
+			pendingEvents.push(event);
+			return refundTxn;
+		});
+		await this.deps.bridges.ledger?.onRefundProcessed?.(transaction, refundTransaction, ctx);
+		await this.deps.bridges.notification?.onRefundProcessed?.(refundTransaction, ctx);
+		for (const ev of pendingEvents) await this.publishToTransport(ev);
+		return refundTransaction;
+	}
+	/** Handles provider webhook. Returns the updated transaction doc (or null if not found). */
+	async handleWebhook(providerName, payload, headers, ctx = {}) {
+		const webhookEvent = await this.deps.providers.get(providerName).handleWebhook(payload, headers);
+		const readOpts = this.optsFromCtx(ctx, { throwOnNotFound: false });
+		const sessionId = webhookEvent.data?.sessionId;
+		const intentId = webhookEvent.data?.paymentIntentId;
+		let transaction = sessionId ? await this.getByQuery({ "gateway.sessionId": sessionId }, readOpts) : null;
+		if (!transaction && intentId) transaction = await this.getByQuery({ "gateway.paymentIntentId": intentId }, readOpts);
+		if (!transaction) return null;
+		if (transaction.webhook?.eventId === webhookEvent.id) return transaction;
+		const nextWebhook = {
+			eventId: webhookEvent.id,
+			eventType: webhookEvent.type,
+			receivedAt: /* @__PURE__ */ new Date(),
+			processedAt: /* @__PURE__ */ new Date(),
+			data: webhookEvent.data
+		};
+		const updated = await this.Model.findOneAndUpdate({
+			_id: transaction._id,
+			"webhook.eventId": { $ne: webhookEvent.id }
+		}, { $set: { webhook: nextWebhook } }, { returnDocument: "after" }).lean();
+		if (!updated) return await this.getByQuery({ _id: transaction._id }, readOpts) ?? transaction;
+		await this.dispatch(createEvent(REVENUE_EVENTS.WEBHOOK_PROCESSED, {
+			webhookType: webhookEvent.type,
+			provider: providerName,
+			event: webhookEvent,
+			transaction: updated
+		}, ctx, {
+			resource: "transaction",
+			resourceId: updated?.publicId
+		}), ctx);
+		return updated;
+	}
+	/** Places hold on verified transaction. Returns the updated doc. */
+	async hold(transactionId, options = {}, ctx = {}) {
+		const transaction = await this.getById(transactionId, this.optsFromCtx(ctx));
+		if (!transaction) throw new TransactionNotFoundError(transactionId);
+		if (transaction.status !== TRANSACTION_STATUS.VERIFIED) throw new ValidationError("Can only hold verified transactions", { status: transaction.status });
+		const holdAmount = options.amount ?? transaction.amount;
+		const updated = await this.update(transactionId, { hold: {
+			status: HOLD_STATUS.HELD,
+			heldAmount: holdAmount,
+			releasedAmount: 0,
+			reason: options.reason ?? "manual_hold",
+			heldAt: /* @__PURE__ */ new Date(),
+			holdUntil: options.holdUntil,
+			releases: [],
+			metadata: options.metadata
+		} }, this.optsFromCtx(ctx));
+		await this.dispatch(createEvent(REVENUE_EVENTS.ESCROW_HELD, {
+			transaction: updated,
+			heldAmount: holdAmount,
+			reason: options.reason
+		}, ctx, {
+			resource: "transaction",
+			resourceId: updated?.publicId
+		}), ctx);
+		return updated;
+	}
+	/**
+	* Releases held funds. Returns the updated transaction doc.
+	*
+	* The hold update and the escrow_release transaction create happen inside
+	* `withTransaction` — a mid-flow crash can't leave the hold marked released
+	* without the corresponding outflow record (or vice versa).
+	*/
+	async release(transactionId, options, ctx = {}) {
+		const transaction = await this.getById(transactionId, this.optsFromCtx(ctx));
+		if (!transaction) throw new TransactionNotFoundError(transactionId);
+		if (!transaction.hold || transaction.hold.status !== HOLD_STATUS.HELD && transaction.hold.status !== HOLD_STATUS.PARTIALLY_RELEASED) throw new ValidationError("Transaction does not have an active hold");
+		const releaseAmount = options.amount ?? transaction.hold.heldAmount - transaction.hold.releasedAmount;
+		const newReleasedAmount = transaction.hold.releasedAmount + releaseAmount;
+		const isFullRelease = newReleasedAmount >= transaction.hold.heldAmount;
+		const release = {
+			amount: releaseAmount,
+			recipientId: options.recipientId,
+			recipientType: options.recipientType,
+			releasedAt: /* @__PURE__ */ new Date(),
+			releasedBy: options.releasedBy,
+			reason: options.reason,
+			metadata: options.metadata
+		};
+		const pendingEvents = [];
+		const updated = await withTransaction(this.Model.db, async (session) => {
+			const writeOpts = this.optsFromCtx(ctx, { session });
+			const result = await this.update(transactionId, { hold: {
+				...transaction.hold,
+				status: isFullRelease ? HOLD_STATUS.RELEASED : HOLD_STATUS.PARTIALLY_RELEASED,
+				releasedAmount: newReleasedAmount,
+				releasedAt: isFullRelease ? /* @__PURE__ */ new Date() : transaction.hold.releasedAt,
+				releases: [...transaction.hold.releases ?? [], release]
+			} }, writeOpts);
+			if (options.createTransaction !== false) await this.create({
+				organizationId: transaction.organizationId,
+				customerId: options.recipientId,
+				type: "escrow_release",
+				flow: "outflow",
+				tags: ["escrow", "release"],
+				amount: releaseAmount,
+				currency: transaction.currency,
+				fee: 0,
+				tax: 0,
+				net: releaseAmount,
+				method: transaction.method,
+				status: TRANSACTION_STATUS.VERIFIED,
+				relatedTransactionId: transaction._id,
+				sourceId: transaction.sourceId,
+				sourceModel: transaction.sourceModel,
+				verifiedAt: /* @__PURE__ */ new Date(),
+				metadata: options.metadata
+			}, writeOpts);
+			const event = createEvent(REVENUE_EVENTS.ESCROW_RELEASED, {
+				transaction: result,
+				releaseAmount,
+				recipientId: options.recipientId,
+				recipientType: options.recipientType,
+				isFullRelease,
+				isPartialRelease: !isFullRelease
+			}, ctx, {
+				resource: "transaction",
+				resourceId: result?.publicId
+			});
+			await this.saveToOutbox(event, session);
+			pendingEvents.push(event);
+			return result;
+		});
+		for (const ev of pendingEvents) await this.publishToTransport(ev);
+		return updated;
+	}
+	/**
+	* Splits payment among recipients. Returns the updated transaction doc.
+	*
+	* N + 2 writes (one create per recipient, one update on the parent, one
+	* platform_revenue create) all commit atomically. Partial splits are the
+	* worst class of bug in a payments system — this is exactly what
+	* `withTransaction` is for.
+	*/
+	async split(transactionId, rules, ctx = {}) {
+		const transaction = await this.getById(transactionId, this.optsFromCtx(ctx));
+		if (!transaction) throw new TransactionNotFoundError(transactionId);
+		const gatewayFeeRate = this.deps.commission?.gatewayFeeRate ?? 0;
+		const splits = calculateSplits(transaction.amount, rules, gatewayFeeRate);
+		const orgPayout = calculateOrganizationPayout(transaction.amount, splits);
+		const pendingEvents = [];
+		const updated = await withTransaction(this.Model.db, async (session) => {
+			const writeOpts = this.optsFromCtx(ctx, { session });
+			for (const s of splits) await this.create({
+				organizationId: transaction.organizationId,
+				customerId: s.recipientId,
+				type: "commission",
+				flow: "outflow",
+				tags: ["split", s.type],
+				amount: s.grossAmount,
+				currency: transaction.currency,
+				fee: s.gatewayFeeAmount,
+				tax: 0,
+				net: s.netAmount,
+				method: transaction.method,
+				status: TRANSACTION_STATUS.VERIFIED,
+				relatedTransactionId: transaction._id,
+				sourceId: transaction.sourceId,
+				sourceModel: transaction.sourceModel,
+				verifiedAt: /* @__PURE__ */ new Date()
+			}, writeOpts);
+			const result = await this.update(transactionId, {
+				splits,
+				metadata: {
+					...transaction.metadata,
+					organizationPayout: orgPayout
+				}
+			}, writeOpts);
+			await this.create({
+				organizationId: transaction.organizationId,
+				type: "platform_revenue",
+				flow: "inflow",
+				tags: ["split", "platform"],
+				amount: orgPayout,
+				currency: transaction.currency,
+				fee: 0,
+				tax: 0,
+				net: orgPayout,
+				method: transaction.method,
+				status: TRANSACTION_STATUS.VERIFIED,
+				relatedTransactionId: transaction._id,
+				verifiedAt: /* @__PURE__ */ new Date()
+			}, writeOpts);
+			const event = createEvent(REVENUE_EVENTS.ESCROW_SPLIT, {
+				transaction: result,
+				splits,
+				organizationPayout: orgPayout
+			}, ctx, {
+				resource: "transaction",
+				resourceId: transaction.publicId
+			});
+			await this.saveToOutbox(event, session);
+			pendingEvents.push(event);
+			return result;
+		});
+		for (const ev of pendingEvents) await this.publishToTransport(ev);
+		return updated;
+	}
+};
+
+//#endregion
+//#region src/repositories/subscription.repository.ts
+/**
+* SubscriptionRepository — data layer + domain verbs.
+*
+* CRUD inherited from mongokit. Domain verbs: activate, cancel, pause, resume.
+*
+* Events: each domain verb calls `this.deps.events.publish(createEvent(...))`
+* with a fully-qualified `REVENUE_EVENTS.*` name. Hosts can subscribe glob-style
+* via `revenue.events.subscribe('revenue:subscription.*', handler)` — the
+* injected transport is arc-compatible (PACKAGE_RULES §13–§14).
+*/
+var SubscriptionRepository = class extends Repository {
+	deps;
+	constructor(model, plugins = []) {
+		super(model, plugins);
+	}
+	inject(deps) {
+		this.deps = deps;
+	}
+	/**
+	* Host-owned outbox save → in-process transport publish (PACKAGE_RULES P8).
+	* Session-bound when `ctx.session` is present (atomic outbox row write).
+	*/
+	async dispatch(event, ctx = {}) {
+		if (this.deps.outbox) try {
+			await this.deps.outbox.save(event, ctx.session !== void 0 ? { session: ctx.session } : {});
+		} catch (err) {
+			this.deps.logger?.error("[revenue] outbox.save failed for", event.type, err);
+		}
+		try {
+			await this.deps.events.publish(event);
+		} catch (err) {
+			this.deps.logger?.error("[revenue] events.publish failed for", event.type, err);
+		}
+	}
+	async activate(subscriptionId, options = {}, ctx = {}) {
+		const sub = await this.getById(subscriptionId);
+		if (!sub) throw new SubscriptionNotFoundError(subscriptionId);
+		SUBSCRIPTION_STATE_MACHINE.validate(sub.status, SUBSCRIPTION_STATUS.ACTIVE, subscriptionId);
+		const now = options.timestamp ?? /* @__PURE__ */ new Date();
+		const endDate = new Date(now);
+		if (sub.planKey === "monthly") endDate.setMonth(endDate.getMonth() + 1);
+		else if (sub.planKey === "quarterly") endDate.setMonth(endDate.getMonth() + 3);
+		else if (sub.planKey === "yearly") endDate.setFullYear(endDate.getFullYear() + 1);
+		else endDate.setDate(endDate.getDate() + 30);
+		const updated = await this.update(subscriptionId, {
+			status: SUBSCRIPTION_STATUS.ACTIVE,
+			isActive: true,
+			activatedAt: now,
+			endDate
+		}, { throwOnNotFound: true });
+		if (!updated) throw new SubscriptionNotFoundError(subscriptionId);
+		await this.dispatch(createEvent(REVENUE_EVENTS.SUBSCRIPTION_ACTIVATED, {
+			subscription: updated,
+			activatedAt: now
+		}, ctx, {
+			resource: "subscription",
+			resourceId: updated?.publicId
+		}), ctx);
+		return updated;
+	}
+	async cancel(subscriptionId, options = {}, ctx = {}) {
+		const sub = await this.getById(subscriptionId);
+		if (!sub) throw new SubscriptionNotFoundError(subscriptionId);
+		SUBSCRIPTION_STATE_MACHINE.validate(sub.status, SUBSCRIPTION_STATUS.CANCELLED, subscriptionId);
+		const updates = {
+			status: SUBSCRIPTION_STATUS.CANCELLED,
+			isActive: false,
+			canceledAt: /* @__PURE__ */ new Date(),
+			cancellationReason: options.reason
+		};
+		if (!options.immediate && sub.endDate) {
+			updates.cancelAt = sub.endDate;
+			updates.status = sub.status;
+			updates.isActive = sub.isActive;
+			delete updates.canceledAt;
+		}
+		const updated = await this.update(subscriptionId, updates, { throwOnNotFound: true });
+		if (!updated) throw new SubscriptionNotFoundError(subscriptionId);
+		await this.dispatch(createEvent(REVENUE_EVENTS.SUBSCRIPTION_CANCELLED, {
+			subscription: updated,
+			immediate: options.immediate,
+			reason: options.reason
+		}, ctx, {
+			resource: "subscription",
+			resourceId: updated?.publicId
+		}), ctx);
+		return updated;
+	}
+	async pause(subscriptionId, options = {}, ctx = {}) {
+		const sub = await this.getById(subscriptionId);
+		if (!sub) throw new SubscriptionNotFoundError(subscriptionId);
+		SUBSCRIPTION_STATE_MACHINE.validate(sub.status, SUBSCRIPTION_STATUS.PAUSED, subscriptionId);
+		const updated = await this.update(subscriptionId, {
+			status: SUBSCRIPTION_STATUS.PAUSED,
+			isActive: false,
+			pausedAt: /* @__PURE__ */ new Date(),
+			pauseReason: options.reason
+		}, { throwOnNotFound: true });
+		if (!updated) throw new SubscriptionNotFoundError(subscriptionId);
+		await this.dispatch(createEvent(REVENUE_EVENTS.SUBSCRIPTION_PAUSED, {
+			subscription: updated,
+			reason: options.reason
+		}, ctx, {
+			resource: "subscription",
+			resourceId: updated?.publicId
+		}), ctx);
+		return updated;
+	}
+	async resume(subscriptionId, options = {}, ctx = {}) {
+		const sub = await this.getById(subscriptionId);
+		if (!sub) throw new SubscriptionNotFoundError(subscriptionId);
+		SUBSCRIPTION_STATE_MACHINE.validate(sub.status, SUBSCRIPTION_STATUS.ACTIVE, subscriptionId);
+		const updates = {
+			status: SUBSCRIPTION_STATUS.ACTIVE,
+			isActive: true
+		};
+		if (options.extendPeriod && sub.pausedAt && sub.endDate) {
+			const pauseDuration = Date.now() - sub.pausedAt.getTime();
+			updates.endDate = new Date(sub.endDate.getTime() + pauseDuration);
+		}
+		const updated = await this.update(subscriptionId, updates, { throwOnNotFound: true });
+		if (!updated) throw new SubscriptionNotFoundError(subscriptionId);
+		await this.dispatch(createEvent(REVENUE_EVENTS.SUBSCRIPTION_RESUMED, {
+			subscription: updated,
+			extendPeriod: options.extendPeriod
+		}, ctx, {
+			resource: "subscription",
+			resourceId: updated?.publicId
+		}), ctx);
+		return updated;
+	}
+};
+
+//#endregion
+//#region src/repositories/settlement.repository.ts
+/**
+* SettlementRepository — data layer + domain verbs.
+*
+* CRUD inherited from mongokit. Domain verbs: schedule, processPending, complete, fail.
+*
+* Events are published via the injected `events` transport (arc-compatible).
+* Hosts subscribe glob-style via `revenue.events.subscribe('revenue:settlement.*', h)`.
+* See PACKAGE_RULES §13–§14.
+*/
+var SettlementRepository = class extends Repository {
+	deps;
+	constructor(model, plugins = []) {
+		super(model, plugins);
+	}
+	inject(deps) {
+		this.deps = deps;
+	}
+	/**
+	* Host-owned outbox save → in-process transport publish (PACKAGE_RULES P8).
+	* Session-bound when `ctx.session` is present (atomic outbox row write).
+	*/
+	async dispatch(event, ctx = {}) {
+		if (this.deps.outbox) try {
+			await this.deps.outbox.save(event, ctx.session !== void 0 ? { session: ctx.session } : {});
+		} catch (err) {
+			this.deps.logger?.error("[revenue] outbox.save failed for", event.type, err);
+		}
+		try {
+			await this.deps.events.publish(event);
+		} catch (err) {
+			this.deps.logger?.error("[revenue] events.publish failed for", event.type, err);
+		}
+	}
+	async schedule(params, ctx = {}) {
+		const settlement = await this.create({
+			...params,
+			status: SETTLEMENT_STATUS.PENDING,
+			scheduledAt: params.scheduledAt ?? /* @__PURE__ */ new Date(),
+			retryCount: 0
+		});
+		await this.dispatch(createEvent(REVENUE_EVENTS.SETTLEMENT_SCHEDULED, {
+			settlement,
+			scheduledAt: settlement.scheduledAt
+		}, ctx, {
+			resource: "settlement",
+			resourceId: settlement.publicId
+		}), ctx);
+		return settlement;
+	}
+	async processPending(options = {}, ctx = {}) {
+		const query = {
+			status: "pending",
+			scheduledAt: { $lte: /* @__PURE__ */ new Date() }
+		};
+		if (options.organizationId) query.organizationId = options.organizationId;
+		if (options.payoutMethod) query.payoutMethod = options.payoutMethod;
+		const pending = (await this.getAll({
+			filters: query,
+			limit: options.limit ?? 50,
+			sort: { scheduledAt: 1 }
+		})).docs ?? [];
+		if (options.dryRun) return {
+			processed: pending.length,
+			succeeded: 0,
+			failed: 0,
+			settlements: pending,
+			errors: []
+		};
+		const results = {
+			processed: 0,
+			succeeded: 0,
+			failed: 0,
+			settlements: [],
+			errors: []
+		};
+		for (const settlement of pending) {
+			try {
+				SETTLEMENT_STATE_MACHINE.validate(settlement.status, SETTLEMENT_STATUS.PROCESSING, String(settlement._id));
+				await this.update(settlement._id, {
+					status: SETTLEMENT_STATUS.PROCESSING,
+					processedAt: /* @__PURE__ */ new Date()
+				});
+				results.succeeded++;
+				results.settlements.push(settlement);
+				await this.dispatch(createEvent(REVENUE_EVENTS.SETTLEMENT_PROCESSING, {
+					settlement,
+					processedAt: /* @__PURE__ */ new Date()
+				}, ctx, {
+					resource: "settlement",
+					resourceId: settlement.publicId
+				}), ctx);
+			} catch (err) {
+				results.failed++;
+				results.errors.push({
+					settlementId: settlement._id,
+					error: err
+				});
+			}
+			results.processed++;
+		}
+		return results;
+	}
+	async complete(settlementId, details = {}, ctx = {}) {
+		const settlement = await this.getById(settlementId);
+		if (!settlement) throw new SettlementNotFoundError(settlementId);
+		SETTLEMENT_STATE_MACHINE.validate(settlement.status, SETTLEMENT_STATUS.COMPLETED, settlementId);
+		const updates = {
+			status: SETTLEMENT_STATUS.COMPLETED,
+			completedAt: /* @__PURE__ */ new Date(),
+			notes: details.notes,
+			metadata: {
+				...settlement.metadata,
+				...details.metadata
+			}
+		};
+		if (details.transferReference) updates.bankTransferDetails = {
+			...settlement.bankTransferDetails,
+			transferReference: details.transferReference,
+			transferredAt: details.transferredAt ?? /* @__PURE__ */ new Date()
+		};
+		if (details.transactionHash) updates.cryptoDetails = {
+			...settlement.cryptoDetails,
+			transactionHash: details.transactionHash,
+			transferredAt: details.transferredAt ?? /* @__PURE__ */ new Date()
+		};
+		const updated = await this.update(settlementId, updates, { throwOnNotFound: true });
+		if (!updated) throw new SettlementNotFoundError(settlementId);
+		await this.deps.bridges.ledger?.onSettlementCompleted?.(updated, ctx);
+		await this.deps.bridges.notification?.onSettlementCompleted?.(updated, ctx);
+		await this.dispatch(createEvent(REVENUE_EVENTS.SETTLEMENT_COMPLETED, {
+			settlement: updated,
+			completedAt: /* @__PURE__ */ new Date()
+		}, ctx, {
+			resource: "settlement",
+			resourceId: updated?.publicId
+		}), ctx);
+		return updated;
+	}
+	async fail(settlementId, reason, options = {}, ctx = {}) {
+		const settlement = await this.getById(settlementId);
+		if (!settlement) throw new SettlementNotFoundError(settlementId);
+		if (options.retry) await this.update(settlementId, {
+			status: SETTLEMENT_STATUS.PENDING,
+			retryCount: (settlement.retryCount ?? 0) + 1,
+			failureReason: reason,
+			failureCode: options.code,
+			scheduledAt: new Date(Date.now() + 36e5)
+		});
+		else {
+			SETTLEMENT_STATE_MACHINE.validate(settlement.status, SETTLEMENT_STATUS.FAILED, settlementId);
+			await this.update(settlementId, {
+				status: SETTLEMENT_STATUS.FAILED,
+				failedAt: /* @__PURE__ */ new Date(),
+				failureReason: reason,
+				failureCode: options.code
+			});
+		}
+		const updated = await this.getById(settlementId);
+		await this.dispatch(createEvent(REVENUE_EVENTS.SETTLEMENT_FAILED, {
+			settlement: updated,
+			reason,
+			code: options.code,
+			retry: options.retry
+		}, ctx, {
+			resource: "settlement",
+			resourceId: updated?.publicId
+		}), ctx);
+		return updated;
+	}
+};
+
+//#endregion
+export { SubscriptionRepository as n, TransactionRepository as r, SettlementRepository as t };