@classytic/loyalty 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,191 @@
+# @classytic/loyalty
+
+Loyalty points, tiers, earning rules, referrals, and redemption engine for MongoDB.
+
+Framework-agnostic. Works with Fastify (Arc), Express, NestJS, Next.js, or any Node.js app with a Mongoose connection.
+
+## Install
+
+```bash
+npm install @classytic/loyalty
+# Peer deps:
+npm install mongoose@^9 @classytic/mongokit@^3.4
+```
+
+## Quick Start
+
+```typescript
+import { createLoyaltyEngine } from '@classytic/loyalty';
+import mongoose from 'mongoose';
+
+const engine = createLoyaltyEngine({
+  mongoose: mongoose.connection,
+  tenant: false, // single-tenant (or { field: 'orgId' } for multi-tenant)
+  program: { conversionRate: 10 },
+  redemption: { minPoints: 100, maxRedeemPercent: 50 },
+  referral: { referrerRewardPoints: 200, refereeRewardPoints: 100 },
+});
+
+// 6 services ready to use
+const member = await engine.services.member.enroll(
+  { externalId: 'cust_1', externalType: 'customer', cardId: 'MBR-001' },
+  { actorId: 'admin' },
+);
+
+await engine.services.ledger.earnPoints(
+  { memberId: member._id, points: 500, description: 'Order #123' },
+  { actorId: 'system' },
+);
+```
+
+## Architecture
+
+```
+createLoyaltyEngine(config)
+  -> models         6 Mongoose models (auto-created, OverwriteModel-safe)
+  -> repositories   6 repos (tenant-scoped CRUD, pagination, atomic transitions)
+  -> services       6 services (the public API)
+  -> events         In-process event bus (or plug your own)
+```
+
+### Services
+
+| Service | Purpose |
+|---------|---------|
+| `member` | Enroll, deactivate, reactivate, suspend, getByCardId, getByExternalId |
+| `ledger` | Earn points, adjust points, transaction history, process expirations |
+| `earning` | CRUD earning rules (order, action, category, tier_bonus types) |
+| `tier` | CRUD tier definitions, evaluate members, set/clear overrides |
+| `redemption` | Validate, reserve, confirm, release, cleanup expired reservations |
+| `referral` | Generate codes, record referrals, approve/reject, rate limiting |
+
+### Key Design Decisions
+
+- **Ledger is source of truth.** `Member.balance` is a denormalized cache updated atomically inside MongoDB transactions.
+- **`cardId` is a first-class field.** Public loyalty card identifier, unique, queryable via `getByCardId()`. Separate from `referralCode`.
+- **Tenant isolation end-to-end.** All reads AND mutations (update, updateBalance, atomicStatusTransition, delete) scope by tenant. No raw `_id` bypass.
+- **Idempotency on both earn and adjust.** Prevents double-crediting on retries, cancel+refund, or network failures.
+- **OverwriteModel-safe.** `createLoyaltyEngine()` can be called multiple times on the same connection (hot reload, tests).
+
+## Using with @classytic/arc
+
+The package integrates naturally with Arc's resource pattern. Use `defineResource` with `disableDefaultRoutes: true` and inline handlers that call the engine services:
+
+```typescript
+import { defineResource } from '@classytic/arc';
+import { getLoyaltyEngine } from './loyalty.plugin.js';
+
+export const memberResource = defineResource({
+  name: 'loyalty-member',
+  prefix: '/loyalty/members',
+  disableDefaultRoutes: true,
+  additionalRoutes: [
+    {
+      method: 'POST', path: '/', summary: 'Enroll member',
+      permissions: permissions.loyalty.manage, wrapHandler: false,
+      schema: memberSchemas.enroll,
+      handler: async (req, reply) => {
+        const member = await getLoyaltyEngine().services.member.enroll(
+          { externalId: req.body.customerId, externalType: 'customer' },
+          { actorId: req.user.id },
+        );
+        return reply.code(201).send({ success: true, data: member });
+      },
+    },
+    // ... more routes
+  ],
+});
+```
+
+This is the same pattern used for warehouse resources (`warehouse.resources.ts`) in Arc-based projects.
+
+### Compatibility
+
+| Concept | Arc | Loyalty | Status |
+|---------|-----|---------|--------|
+| `PaginatedResult<T>` | `{ docs, page, limit, total, pages, hasNext, hasPrev }` | Same shape | Identical |
+| Repository | `RepositoryLike` / `CrudRepository<T>` | Domain ports (MemberPort, etc.) | Compatible |
+| Transactions | `session?: unknown` in QueryOptions | `session?: TransactionSession` in method params | Compatible |
+| Events | Arc event registry | `engine.events` (EventEmitterPort) | Bridgeable |
+
+## Multi-tenant
+
+```typescript
+// Single company, multi-branch (Nike with stores)
+createLoyaltyEngine({ tenant: false });
+// Store branchId in transaction metadata for analytics
+
+// Multi-tenant SaaS (Shopify-like)
+createLoyaltyEngine({ tenant: { field: 'organizationId' } });
+
+// Custom tenant field
+createLoyaltyEngine({ tenant: { field: 'companyId', type: 'string', contextKey: 'companyId' } });
+```
+
+## Typed DTOs
+
+All public service methods accept typed inputs:
+
+```typescript
+import type {
+  EnrollInput,
+  EarnPointsInput,
+  AdjustPointsInput,
+  CreateEarningRuleInput,
+  UpdateEarningRuleInput,
+  CreateTierInput,
+  UpdateTierInput,
+  LoyaltyContext,
+} from '@classytic/loyalty';
+```
+
+## Events
+
+```typescript
+import { LoyaltyEvents } from '@classytic/loyalty/events';
+
+engine.events.on(LoyaltyEvents.POINTS_EARNED, (payload) => { /* sync projection */ });
+engine.events.on(LoyaltyEvents.TIER_UPGRADED, (payload) => { /* notify customer */ });
+engine.events.on(LoyaltyEvents.REFERRAL_REWARDED, (payload) => { /* notify both */ });
+```
+
+## Production Cron Jobs
+
+```typescript
+// Every 5 min — release expired point reservations
+await engine.services.redemption.cleanupExpired({ actorId: 'cron' });
+
+// Every hour — expire points past their expiresAt
+await engine.services.ledger.processExpirations({ actorId: 'cron' });
+
+// Every 24h — re-evaluate all member tiers
+await engine.services.tier.evaluateAll({ actorId: 'cron' });
+```
+
+## Error Codes
+
+| Code | HTTP | When |
+|------|------|------|
+| `MEMBER_NOT_FOUND` | 404 | Member doesn't exist |
+| `MEMBER_ALREADY_ENROLLED` | 409 | Duplicate enrollment |
+| `MEMBER_INACTIVE` | 422 | Operating on inactive member |
+| `INSUFFICIENT_POINTS` | 400 | Not enough points to deduct |
+| `RULE_NOT_FOUND` | 404 | Earning rule doesn't exist |
+| `TIER_NOT_FOUND` | 404 | Tier definition doesn't exist |
+| `REDEMPTION_EXPIRED` | 410 | Reservation TTL exceeded |
+| `DUPLICATE_REFERRAL` | 409 | Referee already referred |
+| `SELF_REFERRAL` | 422 | Referring yourself |
+| `REFERRAL_LIMIT_EXCEEDED` | 429 | Max referrals per period |
+| `TENANT_ISOLATION` | 403 | Cross-tenant access attempt |
+
+## AI Agent Skill
+
+Install the agent skill for AI-assisted integration:
+
+```bash
+npx skills add classytic/loyalty
+```
+
+## License
+
+MIT

package/dist/config-aNigy4ec.d.mts

@@ -0,0 +1,90 @@
+import { t as EventEmitterPort } from "./event-emitter.port-CLYPoMni.mjs";
+import { t as NotificationAdapter } from "./notification.port-BzUsH0It.mjs";
+import { Connection } from "mongoose";
+
+//#region src/types/config.d.ts
+interface TenantEnabled {
+  field?: string;
+  ref?: string;
+  type?: 'ObjectId' | 'string';
+  contextKey?: string;
+}
+type TenantConfig = false | TenantEnabled;
+interface IndexDefinition {
+  fields: Record<string, 1 | -1>;
+  options?: Record<string, unknown>;
+}
+type ModelName = 'member' | 'pointTransaction' | 'earningRule' | 'tierDefinition' | 'redemption' | 'referral';
+type PluginType = unknown;
+interface RepositoryPlugins {
+  member?: PluginType[];
+  pointTransaction?: PluginType[];
+  earningRule?: PluginType[];
+  tierDefinition?: PluginType[];
+  redemption?: PluginType[];
+  referral?: PluginType[];
+}
+interface LoyaltyConfig {
+  mongoose: Connection;
+  tenant?: TenantConfig;
+  program?: {
+    id?: string;
+    conversionRate?: number;
+  };
+  redemption?: {
+    minPoints?: number;
+    minOrderAmount?: number;
+    maxRedeemPercent?: number;
+    reservationTtlMinutes?: number;
+  };
+  referral?: {
+    referrerRewardPoints?: number;
+    refereeRewardPoints?: number;
+    maxPerPeriod?: number;
+    periodDays?: number;
+    requireApproval?: boolean;
+    codeLength?: number;
+  };
+  expiry?: {
+    enabled?: boolean;
+    defaultDays?: number;
+  };
+  indexes?: Partial<Record<ModelName, IndexDefinition[]>>;
+  events?: {
+    adapter?: EventEmitterPort;
+  };
+  notifications?: NotificationAdapter;
+  plugins?: RepositoryPlugins;
+}
+interface ResolvedTenant {
+  enabled: boolean;
+  field: string;
+  ref?: string;
+  type: 'ObjectId' | 'string';
+  contextKey: string;
+}
+interface ResolvedConfig {
+  programId: string;
+  conversionRate: number;
+  redemption: {
+    minPoints: number;
+    minOrderAmount: number;
+    maxRedeemPercent: number;
+    reservationTtlMinutes: number;
+  };
+  referral: {
+    referrerRewardPoints: number;
+    refereeRewardPoints: number;
+    maxPerPeriod: number;
+    periodDays: number;
+    requireApproval: boolean;
+    codeLength: number;
+  };
+  expiry: {
+    enabled: boolean;
+    defaultDays?: number;
+  };
+  tenant: ResolvedTenant;
+}
+//#endregion
+export { RepositoryPlugins as a, TenantConfig as c, PluginType as i, LoyaltyConfig as n, ResolvedConfig as o, ModelName as r, ResolvedTenant as s, IndexDefinition as t };

package/dist/constants-C75GvizO.mjs

@@ -0,0 +1,49 @@
+//#region src/constants.ts
+const DEFAULT_TENANT_FIELD = "organizationId";
+const DEFAULT_TENANT_TYPE = "ObjectId";
+const DEFAULT_PROGRAM_ID = "default";
+const TRANSACTION_TYPES = Object.freeze([
+	"earn",
+	"redeem",
+	"adjust",
+	"expire",
+	"transfer",
+	"referral_bonus"
+]);
+const MEMBER_STATUSES = Object.freeze([
+	"active",
+	"inactive",
+	"suspended"
+]);
+const RULE_TYPES = Object.freeze([
+	"order",
+	"action",
+	"category",
+	"tier_bonus"
+]);
+const RULE_STATUSES = Object.freeze([
+	"active",
+	"paused",
+	"expired"
+]);
+const REFERRAL_STATUSES = Object.freeze([
+	"pending",
+	"approved",
+	"rejected",
+	"expired"
+]);
+const REDEMPTION_STATUSES = Object.freeze([
+	"reserved",
+	"confirmed",
+	"released",
+	"expired"
+]);
+const EARNING_ACTIONS = Object.freeze([
+	"signup",
+	"referral",
+	"birthday",
+	"review",
+	"profile_complete"
+]);
+//#endregion
+export { MEMBER_STATUSES as a, RULE_STATUSES as c, EARNING_ACTIONS as i, RULE_TYPES as l, DEFAULT_TENANT_FIELD as n, REDEMPTION_STATUSES as o, DEFAULT_TENANT_TYPE as r, REFERRAL_STATUSES as s, DEFAULT_PROGRAM_ID as t, TRANSACTION_TYPES as u };

package/dist/domain/enums/index.d.mts

@@ -0,0 +1,2 @@
+import { a as RuleStatus, c as EARNING_ACTIONS, d as REFERRAL_STATUSES, f as RULE_STATUSES, i as ReferralStatus, l as MEMBER_STATUSES, m as TRANSACTION_TYPES, n as MemberStatus, o as RuleType, p as RULE_TYPES, r as RedemptionStatus, s as TransactionType, t as EarningAction, u as REDEMPTION_STATUSES } from "../../index-CaH4GhSF.mjs";
+export { EARNING_ACTIONS, EarningAction, MEMBER_STATUSES, MemberStatus, REDEMPTION_STATUSES, REFERRAL_STATUSES, RULE_STATUSES, RULE_TYPES, RedemptionStatus, ReferralStatus, RuleStatus, RuleType, TRANSACTION_TYPES, TransactionType };

package/dist/domain/enums/index.mjs

@@ -0,0 +1,2 @@
+import { a as MEMBER_STATUSES, c as RULE_STATUSES, i as EARNING_ACTIONS, l as RULE_TYPES, o as REDEMPTION_STATUSES, s as REFERRAL_STATUSES, u as TRANSACTION_TYPES } from "../../constants-C75GvizO.mjs";
+export { EARNING_ACTIONS, MEMBER_STATUSES, REDEMPTION_STATUSES, REFERRAL_STATUSES, RULE_STATUSES, RULE_TYPES, TRANSACTION_TYPES };

package/dist/domain/index.d.mts

@@ -0,0 +1,90 @@
+import { a as RuleStatus, c as EARNING_ACTIONS, d as REFERRAL_STATUSES, f as RULE_STATUSES, i as ReferralStatus, l as MEMBER_STATUSES, m as TRANSACTION_TYPES, n as MemberStatus, o as RuleType, p as RULE_TYPES, r as RedemptionStatus, s as TransactionType, t as EarningAction, u as REDEMPTION_STATUSES } from "../index-CaH4GhSF.mjs";
+import { a as PointTransaction, c as EarningConditions, i as TierQualification, l as EarningReward, n as TierDefinition, o as Member, r as TierDowngrade, s as MemberBalance, t as TierBenefits, u as EarningRule } from "../tier-definition-Djf72UPa.mjs";
+import { a as MemberPort, c as UnitOfWork, i as PointTransactionPort, l as Referral, n as ReferralPort, o as EarningRulePort, r as RedemptionPort, s as TransactionSession, t as TierDefinitionPort, u as Redemption } from "../tier-definition.port-BzrHYBRo.mjs";
+import { t as EventEmitterPort } from "../event-emitter.port-CLYPoMni.mjs";
+import { t as NotificationAdapter } from "../notification.port-BzUsH0It.mjs";
+
+//#region src/domain/errors/base.d.ts
+declare abstract class LoyaltyError extends Error {
+  abstract readonly code: string;
+  abstract readonly httpStatus: number;
+  constructor(message: string);
+  toJSON(): {
+    code: string;
+    message: string;
+    name: string;
+  };
+}
+//#endregion
+//#region src/domain/errors/domain-errors.d.ts
+declare class InsufficientPointsError extends LoyaltyError {
+  readonly code = "INSUFFICIENT_POINTS";
+  readonly httpStatus = 400;
+  constructor(available: number, requested: number);
+}
+declare class MemberNotFoundError extends LoyaltyError {
+  readonly code = "MEMBER_NOT_FOUND";
+  readonly httpStatus = 404;
+  constructor(id: string);
+}
+declare class MemberAlreadyEnrolledError extends LoyaltyError {
+  readonly code = "MEMBER_ALREADY_ENROLLED";
+  readonly httpStatus = 409;
+  constructor(externalId: string);
+}
+declare class MemberInactiveError extends LoyaltyError {
+  readonly code = "MEMBER_INACTIVE";
+  readonly httpStatus = 422;
+  constructor(id: string);
+}
+declare class RuleNotFoundError extends LoyaltyError {
+  readonly code = "RULE_NOT_FOUND";
+  readonly httpStatus = 404;
+  constructor(id: string);
+}
+declare class TierNotFoundError extends LoyaltyError {
+  readonly code = "TIER_NOT_FOUND";
+  readonly httpStatus = 404;
+  constructor(id: string);
+}
+declare class RedemptionNotFoundError extends LoyaltyError {
+  readonly code = "REDEMPTION_NOT_FOUND";
+  readonly httpStatus = 404;
+  constructor(id: string);
+}
+declare class RedemptionExpiredError extends LoyaltyError {
+  readonly code = "REDEMPTION_EXPIRED";
+  readonly httpStatus = 410;
+  constructor(id: string);
+}
+declare class ReferralNotFoundError extends LoyaltyError {
+  readonly code = "REFERRAL_NOT_FOUND";
+  readonly httpStatus = 404;
+  constructor(id: string);
+}
+declare class DuplicateReferralError extends LoyaltyError {
+  readonly code = "DUPLICATE_REFERRAL";
+  readonly httpStatus = 409;
+  constructor(refereeId: string);
+}
+declare class ReferralLimitExceededError extends LoyaltyError {
+  readonly code = "REFERRAL_LIMIT_EXCEEDED";
+  readonly httpStatus = 429;
+  constructor(limit: number, periodDays: number);
+}
+declare class SelfReferralError extends LoyaltyError {
+  readonly code = "SELF_REFERRAL";
+  readonly httpStatus = 422;
+  constructor();
+}
+declare class ValidationError extends LoyaltyError {
+  readonly code = "VALIDATION_ERROR";
+  readonly httpStatus = 400;
+}
+declare class TenantIsolationError extends LoyaltyError {
+  readonly code = "TENANT_ISOLATION";
+  readonly httpStatus = 403;
+  constructor();
+}
+//#endregion
+export { DuplicateReferralError, EARNING_ACTIONS, EarningAction, EarningConditions, EarningReward, EarningRule, EarningRulePort, EventEmitterPort, InsufficientPointsError, LoyaltyError, MEMBER_STATUSES, Member, MemberAlreadyEnrolledError, MemberBalance, MemberInactiveError, MemberNotFoundError, MemberPort, MemberStatus, NotificationAdapter, PointTransaction, PointTransactionPort, REDEMPTION_STATUSES, REFERRAL_STATUSES, RULE_STATUSES, RULE_TYPES, Redemption, RedemptionExpiredError, RedemptionNotFoundError, RedemptionPort, RedemptionStatus, Referral, ReferralLimitExceededError, ReferralNotFoundError, ReferralPort, ReferralStatus, RuleNotFoundError, RuleStatus, RuleType, SelfReferralError, TRANSACTION_TYPES, TenantIsolationError, TierBenefits, TierDefinition, TierDefinitionPort, TierDowngrade, TierNotFoundError, TierQualification, TransactionSession, TransactionType, UnitOfWork, ValidationError };

package/dist/domain/index.mjs

@@ -0,0 +1,4 @@
+import { a as MEMBER_STATUSES, c as RULE_STATUSES, i as EARNING_ACTIONS, l as RULE_TYPES, o as REDEMPTION_STATUSES, s as REFERRAL_STATUSES, u as TRANSACTION_TYPES } from "../constants-C75GvizO.mjs";
+import { a as MemberInactiveError, c as RedemptionNotFoundError, d as RuleNotFoundError, f as SelfReferralError, g as LoyaltyError, h as ValidationError, i as MemberAlreadyEnrolledError, l as ReferralLimitExceededError, m as TierNotFoundError, n as DuplicateReferralError, o as MemberNotFoundError, p as TenantIsolationError, r as InsufficientPointsError, s as RedemptionExpiredError, u as ReferralNotFoundError } from "../domain-errors-D7q-2LYD.mjs";
+import "./enums/index.mjs";
+export { DuplicateReferralError, EARNING_ACTIONS, InsufficientPointsError, LoyaltyError, MEMBER_STATUSES, MemberAlreadyEnrolledError, MemberInactiveError, MemberNotFoundError, REDEMPTION_STATUSES, REFERRAL_STATUSES, RULE_STATUSES, RULE_TYPES, RedemptionExpiredError, RedemptionNotFoundError, ReferralLimitExceededError, ReferralNotFoundError, RuleNotFoundError, SelfReferralError, TRANSACTION_TYPES, TenantIsolationError, TierNotFoundError, ValidationError };

package/dist/domain-errors-D7q-2LYD.mjs

@@ -0,0 +1,120 @@
+//#region src/domain/errors/base.ts
+var LoyaltyError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
+	}
+	toJSON() {
+		return {
+			code: this.code,
+			message: this.message,
+			name: this.name
+		};
+	}
+};
+//#endregion
+//#region src/domain/errors/domain-errors.ts
+var InsufficientPointsError = class extends LoyaltyError {
+	code = "INSUFFICIENT_POINTS";
+	httpStatus = 400;
+	constructor(available, requested) {
+		super(`Insufficient points. Available: ${available}, requested: ${requested}`);
+	}
+};
+var MemberNotFoundError = class extends LoyaltyError {
+	code = "MEMBER_NOT_FOUND";
+	httpStatus = 404;
+	constructor(id) {
+		super(`Member not found: ${id}`);
+	}
+};
+var MemberAlreadyEnrolledError = class extends LoyaltyError {
+	code = "MEMBER_ALREADY_ENROLLED";
+	httpStatus = 409;
+	constructor(externalId) {
+		super(`Member already enrolled: ${externalId}`);
+	}
+};
+var MemberInactiveError = class extends LoyaltyError {
+	code = "MEMBER_INACTIVE";
+	httpStatus = 422;
+	constructor(id) {
+		super(`Member is not active: ${id}`);
+	}
+};
+var RuleNotFoundError = class extends LoyaltyError {
+	code = "RULE_NOT_FOUND";
+	httpStatus = 404;
+	constructor(id) {
+		super(`Earning rule not found: ${id}`);
+	}
+};
+var TierNotFoundError = class extends LoyaltyError {
+	code = "TIER_NOT_FOUND";
+	httpStatus = 404;
+	constructor(id) {
+		super(`Tier not found: ${id}`);
+	}
+};
+var RedemptionNotFoundError = class extends LoyaltyError {
+	code = "REDEMPTION_NOT_FOUND";
+	httpStatus = 404;
+	constructor(id) {
+		super(`Redemption not found: ${id}`);
+	}
+};
+var RedemptionExpiredError = class extends LoyaltyError {
+	code = "REDEMPTION_EXPIRED";
+	httpStatus = 410;
+	constructor(id) {
+		super(`Redemption expired: ${id}`);
+	}
+};
+var ReferralNotFoundError = class extends LoyaltyError {
+	code = "REFERRAL_NOT_FOUND";
+	httpStatus = 404;
+	constructor(id) {
+		super(`Referral not found: ${id}`);
+	}
+};
+var DuplicateReferralError = class extends LoyaltyError {
+	code = "DUPLICATE_REFERRAL";
+	httpStatus = 409;
+	constructor(refereeId) {
+		super(`Referee already has a referral: ${refereeId}`);
+	}
+};
+var ReferralLimitExceededError = class extends LoyaltyError {
+	code = "REFERRAL_LIMIT_EXCEEDED";
+	httpStatus = 429;
+	constructor(limit, periodDays) {
+		super(`Referral limit of ${limit} per ${periodDays} days exceeded`);
+	}
+};
+var SelfReferralError = class extends LoyaltyError {
+	code = "SELF_REFERRAL";
+	httpStatus = 422;
+	constructor() {
+		super("Cannot refer yourself");
+	}
+};
+var CircularReferralError = class extends LoyaltyError {
+	code = "CIRCULAR_REFERRAL";
+	httpStatus = 422;
+	constructor() {
+		super("Circular referral detected");
+	}
+};
+var ValidationError = class extends LoyaltyError {
+	code = "VALIDATION_ERROR";
+	httpStatus = 400;
+};
+var TenantIsolationError = class extends LoyaltyError {
+	code = "TENANT_ISOLATION";
+	httpStatus = 403;
+	constructor() {
+		super("Tenant context is required but not provided");
+	}
+};
+//#endregion
+export { MemberInactiveError as a, RedemptionNotFoundError as c, RuleNotFoundError as d, SelfReferralError as f, LoyaltyError as g, ValidationError as h, MemberAlreadyEnrolledError as i, ReferralLimitExceededError as l, TierNotFoundError as m, DuplicateReferralError as n, MemberNotFoundError as o, TenantIsolationError as p, InsufficientPointsError as r, RedemptionExpiredError as s, CircularReferralError as t, ReferralNotFoundError as u };

package/dist/event-emitter.port-CLYPoMni.d.mts

@@ -0,0 +1,8 @@
+//#region src/domain/ports/event-emitter.port.d.ts
+interface EventEmitterPort {
+  emit(event: string, payload: unknown): void;
+  on(event: string, handler: (payload: unknown) => void | Promise<void>): void;
+  off(event: string, handler: (payload: unknown) => void | Promise<void>): void;
+}
+//#endregion
+export { EventEmitterPort as t };

package/dist/event-types-xQBtYBbX.mjs

@@ -0,0 +1,24 @@
+//#region src/events/event-types.ts
+const LoyaltyEvents = {
+	MEMBER_ENROLLED: "loyalty.member.enrolled",
+	MEMBER_DEACTIVATED: "loyalty.member.deactivated",
+	MEMBER_REACTIVATED: "loyalty.member.reactivated",
+	MEMBER_SUSPENDED: "loyalty.member.suspended",
+	POINTS_EARNED: "loyalty.points.earned",
+	POINTS_REDEEMED: "loyalty.points.redeemed",
+	POINTS_ADJUSTED: "loyalty.points.adjusted",
+	POINTS_EXPIRED: "loyalty.points.expired",
+	POINTS_EXPIRING_SOON: "loyalty.points.expiring_soon",
+	TIER_UPGRADED: "loyalty.tier.upgraded",
+	TIER_DOWNGRADED: "loyalty.tier.downgraded",
+	TIER_GRACE_STARTED: "loyalty.tier.grace_started",
+	REDEMPTION_RESERVED: "loyalty.redemption.reserved",
+	REDEMPTION_CONFIRMED: "loyalty.redemption.confirmed",
+	REDEMPTION_RELEASED: "loyalty.redemption.released",
+	REFERRAL_RECORDED: "loyalty.referral.recorded",
+	REFERRAL_APPROVED: "loyalty.referral.approved",
+	REFERRAL_REJECTED: "loyalty.referral.rejected",
+	REFERRAL_REWARDED: "loyalty.referral.rewarded"
+};
+//#endregion
+export { LoyaltyEvents as t };

package/dist/events/index.d.mts

@@ -0,0 +1,2 @@
+import { a as PointsEarnedPayload, c as TierChangedPayload, i as PointsAdjustedPayload, l as InProcessEventBus, n as LoyaltyEvents, o as RedemptionPayload, r as MemberLifecyclePayload, s as ReferralPayload, t as LoyaltyEvent } from "../index-O7TL4R2P.mjs";
+export { InProcessEventBus, LoyaltyEvent, LoyaltyEvents, MemberLifecyclePayload, PointsAdjustedPayload, PointsEarnedPayload, RedemptionPayload, ReferralPayload, TierChangedPayload };

package/dist/events/index.mjs

@@ -0,0 +1,3 @@
+import { t as InProcessEventBus } from "../events-CprEWlN7.mjs";
+import { t as LoyaltyEvents } from "../event-types-xQBtYBbX.mjs";
+export { InProcessEventBus, LoyaltyEvents };

package/dist/events-CprEWlN7.mjs

@@ -0,0 +1,25 @@
+//#region src/events/event-bus.ts
+var InProcessEventBus = class {
+	handlers = /* @__PURE__ */ new Map();
+	emit(event, payload) {
+		const set = this.handlers.get(event);
+		if (!set) return;
+		for (const handler of set) try {
+			const result = handler(payload);
+			if (result && typeof result.catch === "function") result.catch(() => {});
+		} catch {}
+	}
+	on(event, handler) {
+		let set = this.handlers.get(event);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.handlers.set(event, set);
+		}
+		set.add(handler);
+	}
+	off(event, handler) {
+		this.handlers.get(event)?.delete(handler);
+	}
+};
+//#endregion
+export { InProcessEventBus as t };