@happyvertical/smrt-sales 0.39.2

package/dist/chunks/referrals-BY47p70T.js

@@ -0,0 +1,2880 @@
+import { D as CommissionCollection, p as CommissionPlanCollection, r as CommissionCalculationService } from "./commissions-BCxqOKVM.js";
+import { SmrtCollection, SmrtObject, crossPackageRef, field, foreignKey, smrt } from "@happyvertical/smrt-core";
+import { TenantScoped, tenantId } from "@happyvertical/smrt-tenancy";
+import { randomBytes, randomUUID } from "node:crypto";
+//#region src/referrals/models/AttributionException.ts
+var __defProp$8 = Object.defineProperty;
+var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
+var __decorateClass$8 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$8(target, key, result);
+	return result;
+};
+var AttributionException = class extends SmrtObject {
+	tenantId = null;
+	targetKind = "";
+	targetId = "";
+	programId = "";
+	/** `open` (default, awaiting review) or `resolved`. */
+	status = "open";
+	/**
+	* Why the exception was raised — recommended vocabulary: `'tie'`
+	* (exact-timestamp tie between distinct referrers),
+	* `'competing_touches'` (competing manual assignments), and
+	* `'policy_review'` (`conflictBehavior: 'review'` with multiple
+	* referrers). Open string.
+	*/
+	conflictReason = "";
+	/**
+	* The competing touches as a JSON-string array of
+	* {@link AttributionExceptionCandidate}. Use
+	* {@link getCandidates}/{@link setCandidates}.
+	*/
+	candidates = "[]";
+	/**
+	* How the exception was resolved — `'override'` (human award) or
+	* `'policy'` (policy re-run). Empty while open.
+	*/
+	resolutionMode = "";
+	/** Why credit was awarded the way it was. REQUIRED to resolve. */
+	resolutionReason = "";
+	resolvedByProfileId = "";
+	/**
+	* Ids of the Referral rows the resolution created, as a JSON-string
+	* array. Use {@link getResolvedReferralIds}/{@link setResolvedReferralIds}.
+	*/
+	resolvedReferralIds = "[]";
+	/** When the exception was resolved. */
+	resolvedAt = null;
+	/**
+	* Free-form JSON object stored as a string (the attribution service
+	* stamps the policy pin here for later resolution). Use
+	* {@link getMetadata}/{@link setMetadata}.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.targetKind !== void 0) this.targetKind = options.targetKind;
+		if (options.targetId !== void 0) this.targetId = options.targetId;
+		if (options.programId !== void 0) this.programId = options.programId;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.conflictReason !== void 0) this.conflictReason = options.conflictReason;
+		if (options.candidates !== void 0) this.candidates = options.candidates;
+		if (options.resolutionMode !== void 0) this.resolutionMode = options.resolutionMode;
+		if (options.resolutionReason !== void 0) this.resolutionReason = options.resolutionReason;
+		if (options.resolvedByProfileId !== void 0) this.resolvedByProfileId = options.resolvedByProfileId;
+		if (options.resolvedReferralIds !== void 0) this.resolvedReferralIds = options.resolvedReferralIds;
+		if (options.resolvedAt !== void 0) this.resolvedAt = AttributionException.coerceDate(options.resolvedAt);
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Re-coerce date fields after the framework reapplies raw option values. */
+	async initialize() {
+		await super.initialize();
+		this.resolvedAt = AttributionException.coerceDate(this.resolvedAt);
+		return this;
+	}
+	/** Whether the exception still awaits review. */
+	isOpen() {
+		return this.status === "open";
+	}
+	/** Parse {@link candidates}; returns `[]` on empty/invalid JSON. */
+	getCandidates() {
+		if (!this.candidates) return [];
+		try {
+			const parsed = JSON.parse(this.candidates);
+			return Array.isArray(parsed) ? parsed : [];
+		} catch {
+			return [];
+		}
+	}
+	/** Serialize and store {@link candidates}. */
+	setCandidates(candidates) {
+		this.candidates = JSON.stringify(candidates ?? []);
+	}
+	/** Parse {@link resolvedReferralIds}; returns `[]` on empty/invalid JSON. */
+	getResolvedReferralIds() {
+		if (!this.resolvedReferralIds) return [];
+		try {
+			const parsed = JSON.parse(this.resolvedReferralIds);
+			return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
+		} catch {
+			return [];
+		}
+	}
+	/** Serialize and store {@link resolvedReferralIds}. */
+	setResolvedReferralIds(ids) {
+		this.resolvedReferralIds = JSON.stringify(ids ?? []);
+	}
+	/** Parse {@link metadata}; returns `{}` on malformed content. */
+	getMetadata() {
+		if (!this.metadata) return {};
+		try {
+			const parsed = JSON.parse(this.metadata);
+			return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store {@link metadata}. */
+	setMetadata(data) {
+		this.metadata = JSON.stringify(data ?? {});
+	}
+	/**
+	* Mark the exception resolved (mutates; the caller saves). Requires a
+	* non-empty reason — resolutions without a recorded rationale are
+	* rejected.
+	*/
+	markResolved(input) {
+		if (this.status !== "open") throw new Error(`AttributionException ${this.id ?? "<new>"}: cannot resolve from status '${this.status}'`);
+		if (!input.reason?.trim()) throw new Error(`AttributionException ${this.id ?? "<new>"}: a non-empty resolutionReason is required`);
+		this.status = "resolved";
+		this.resolutionMode = input.mode;
+		this.resolutionReason = input.reason;
+		this.resolvedByProfileId = input.resolvedByProfileId ?? "";
+		this.setResolvedReferralIds(input.referralIds);
+		this.resolvedAt = input.at ?? /* @__PURE__ */ new Date();
+	}
+	static coerceDate(value) {
+		if (value == null) return null;
+		if (value instanceof Date) return value;
+		if (typeof value === "number" || typeof value === "string") {
+			const d = new Date(value);
+			return Number.isNaN(d.getTime()) ? null : d;
+		}
+		return null;
+	}
+};
+__decorateClass$8([tenantId({ nullable: true })], AttributionException.prototype, "tenantId", 2);
+__decorateClass$8([field({ required: true })], AttributionException.prototype, "targetKind", 2);
+__decorateClass$8([field({ required: true })], AttributionException.prototype, "targetId", 2);
+__decorateClass$8([foreignKey("ReferralProgram")], AttributionException.prototype, "programId", 2);
+__decorateClass$8([crossPackageRef("@happyvertical/smrt-profiles:Profile")], AttributionException.prototype, "resolvedByProfileId", 2);
+AttributionException = __decorateClass$8([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: ["list", "get"] },
+	mcp: { include: ["list", "get"] },
+	cli: false
+})], AttributionException);
+//#endregion
+//#region src/referrals/collections/AttributionExceptionCollection.ts
+var AttributionExceptionCollection = class extends SmrtCollection {
+	static _itemClass = AttributionException;
+	/** Every open exception, oldest first (the review queue). */
+	async findOpen() {
+		return await this.list({
+			where: { status: "open" },
+			orderBy: "created_at ASC"
+		});
+	}
+	/**
+	* The open exception for one target within one program, or `null`.
+	* `AttributionService.resolve()` returns this instead of minting a
+	* duplicate when a conflict is already parked for review.
+	*/
+	async findOpenByTarget(targetKind, targetId, programId) {
+		return (await this.list({
+			where: {
+				targetKind,
+				targetId,
+				programId,
+				status: "open"
+			},
+			orderBy: "created_at ASC",
+			limit: 1
+		}))[0] ?? null;
+	}
+	/** Every exception (open and resolved) for one target, newest first. */
+	async findByTarget(targetKind, targetId) {
+		return await this.list({
+			where: {
+				targetKind,
+				targetId
+			},
+			orderBy: "created_at DESC"
+		});
+	}
+};
+//#endregion
+//#region src/referrals/types.ts
+var REFERRER_STATUSES = [
+	"pending",
+	"active",
+	"suspended"
+];
+var REFERRAL_PROGRAM_STATUSES = [
+	"draft",
+	"active",
+	"paused",
+	"archived"
+];
+var ATTRIBUTION_POLICY_STATUSES = [
+	"draft",
+	"active",
+	"superseded",
+	"retired"
+];
+var ATTRIBUTION_CREDIT_MODES = [
+	"first_touch",
+	"last_touch",
+	"assigned",
+	"split"
+];
+var ATTRIBUTION_CONFLICT_BEHAVIORS = ["auto", "review"];
+var REFERRAL_LINK_STATUSES = ["active", "disabled"];
+var REFERRAL_TOUCH_KINDS = [
+	"click",
+	"code_entry",
+	"manual_assignment",
+	"partner_entry"
+];
+var REFERRAL_STATUSES = [
+	"pending",
+	"attributed",
+	"qualified",
+	"disqualified",
+	"expired",
+	"under_review"
+];
+var ATTRIBUTION_EXCEPTION_STATUSES = ["open", "resolved"];
+var ATTRIBUTION_RESOLUTION_MODES = ["override", "policy"];
+var REFERRAL_AGREEMENT_STATUSES = [
+	"draft",
+	"active",
+	"superseded",
+	"terminated"
+];
+var REFERRAL_AGREEMENT_APPROVAL_MODES = ["manual", "auto"];
+//#endregion
+//#region src/referrals/models/AttributionPolicy.ts
+var __defProp$7 = Object.defineProperty;
+var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
+var __decorateClass$7 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$7(target, key, result);
+	return result;
+};
+var POLICY_STATUS_TRANSITIONS = {
+	draft: ["active", "retired"],
+	active: ["superseded", "retired"],
+	superseded: [],
+	retired: []
+};
+var loadedPolicyStatus = /* @__PURE__ */ new WeakMap();
+var frozenPolicySnapshot = /* @__PURE__ */ new WeakMap();
+function validateAttributionPolicyTerms(policy) {
+	if (!Number.isInteger(policy.windowDays) || policy.windowDays <= 0) throw new Error(`AttributionPolicy ${policy.policyKey}@${policy.version}: windowDays must be a positive integer`);
+	if (!ATTRIBUTION_CREDIT_MODES.includes(policy.creditMode)) throw new Error(`AttributionPolicy ${policy.policyKey}@${policy.version}: invalid creditMode '${policy.creditMode}'`);
+	if (!ATTRIBUTION_CONFLICT_BEHAVIORS.includes(policy.conflictBehavior)) throw new Error(`AttributionPolicy ${policy.policyKey}@${policy.version}: invalid conflictBehavior '${policy.conflictBehavior}'`);
+	for (const [name, raw] of [
+		["eligibleServices", policy.eligibleServices],
+		["eligibleCampaigns", policy.eligibleCampaigns],
+		["eligibleRegions", policy.eligibleRegions]
+	]) {
+		let parsed;
+		try {
+			parsed = JSON.parse(raw || "[]");
+		} catch {
+			throw new Error(`AttributionPolicy ${policy.policyKey}@${policy.version}: ${name} must be a JSON array of strings`);
+		}
+		if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string")) throw new Error(`AttributionPolicy ${policy.policyKey}@${policy.version}: ${name} must be a JSON array of strings`);
+	}
+}
+var AttributionPolicy = class extends SmrtObject {
+	tenantId = null;
+	policyKey = "";
+	/** Monotonic version within `policyKey`. Amendments insert `max + 1`. */
+	version = 1;
+	/**
+	* Lifecycle status — see {@link POLICY_STATUS_TRANSITIONS}. Mutate via
+	* {@link activate} / {@link supersede} / {@link retire} (or a legal
+	* single-step assignment; the save-time guard rejects illegal edges).
+	*/
+	status = "draft";
+	/** When this version takes effect. Frozen once the policy activates. */
+	effectiveFrom = null;
+	/**
+	* Attribution window in days: only touches occurring within `windowDays`
+	* of the resolution instant are credit candidates, and attributed
+	* referrals expire `windowDays` after attribution if never qualified.
+	*/
+	windowDays = 30;
+	/** How competing touches are credited. */
+	creditMode = "first_touch";
+	/** Whether multi-referrer contention auto-resolves or forces review. */
+	conflictBehavior = "auto";
+	/**
+	* Whether a touch whose referrer IS the prospect (matching
+	* `subjectProfileId`) may earn credit. Default false: self-referrals are
+	* dropped from candidate sets.
+	*/
+	allowSelfReferral = false;
+	/**
+	* Whether referrals of already-existing clients are eligible. Default
+	* false: `AttributionService.resolve()` refuses outright when the caller
+	* flags the prospect as an existing client.
+	*/
+	allowExistingClients = false;
+	/**
+	* Eligible service keys as a JSON-string array — empty array means ALL
+	* services are eligible. Interpretation belongs to the application layer
+	* that maps its offerings onto service keys; this module records and
+	* validates the list. Use {@link getEligibleServices}/{@link setEligibleServices}.
+	*/
+	eligibleServices = "[]";
+	/** Eligible campaign keys (JSON-string array; empty = all eligible). */
+	eligibleCampaigns = "[]";
+	/** Eligible region codes (JSON-string array; empty = all eligible). */
+	eligibleRegions = "[]";
+	/** Additional metadata as a JSON string (not part of the frozen identity). */
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.policyKey !== void 0) this.policyKey = options.policyKey;
+		if (options.version !== void 0) this.version = options.version;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.effectiveFrom !== void 0) this.effectiveFrom = AttributionPolicy.coerceDate(options.effectiveFrom);
+		if (options.windowDays !== void 0) this.windowDays = options.windowDays;
+		if (options.creditMode !== void 0) this.creditMode = options.creditMode;
+		if (options.conflictBehavior !== void 0) this.conflictBehavior = options.conflictBehavior;
+		if (options.allowSelfReferral !== void 0) this.allowSelfReferral = options.allowSelfReferral;
+		if (options.allowExistingClients !== void 0) this.allowExistingClients = options.allowExistingClients;
+		if (options.eligibleServices !== void 0) this.eligibleServices = options.eligibleServices;
+		if (options.eligibleCampaigns !== void 0) this.eligibleCampaigns = options.eligibleCampaigns;
+		if (options.eligibleRegions !== void 0) this.eligibleRegions = options.eligibleRegions;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/**
+	* Re-coerce date fields after the framework reapplies raw option values,
+	* record the loaded status for the transition guard, and capture the
+	* frozen snapshot when the row arrived already non-draft (superseded and
+	* retired versions — history — can't be rewritten either).
+	*/
+	async initialize() {
+		await super.initialize();
+		this.effectiveFrom = AttributionPolicy.coerceDate(this.effectiveFrom);
+		if (await this.isSaved()) {
+			loadedPolicyStatus.set(this, this.status);
+			if (this.status !== "draft") frozenPolicySnapshot.set(this, this.serializeFrozenSnapshot());
+		}
+		return this;
+	}
+	isDraft() {
+		return this.status === "draft";
+	}
+	isActive() {
+		return this.status === "active";
+	}
+	/** Parse {@link eligibleServices}; returns `[]` on empty/invalid JSON. */
+	getEligibleServices() {
+		return AttributionPolicy.parseStringArray(this.eligibleServices);
+	}
+	/** Serialize and store {@link eligibleServices}. */
+	setEligibleServices(services) {
+		this.eligibleServices = JSON.stringify(services ?? []);
+	}
+	/** Parse {@link eligibleCampaigns}; returns `[]` on empty/invalid JSON. */
+	getEligibleCampaigns() {
+		return AttributionPolicy.parseStringArray(this.eligibleCampaigns);
+	}
+	/** Serialize and store {@link eligibleCampaigns}. */
+	setEligibleCampaigns(campaigns) {
+		this.eligibleCampaigns = JSON.stringify(campaigns ?? []);
+	}
+	/** Parse {@link eligibleRegions}; returns `[]` on empty/invalid JSON. */
+	getEligibleRegions() {
+		return AttributionPolicy.parseStringArray(this.eligibleRegions);
+	}
+	/** Serialize and store {@link eligibleRegions}. */
+	setEligibleRegions(regions) {
+		this.eligibleRegions = JSON.stringify(regions ?? []);
+	}
+	/** Parse {@link metadata}; returns `{}` on empty/invalid JSON. */
+	getMetadata() {
+		if (!this.metadata) return {};
+		try {
+			const parsed = JSON.parse(this.metadata);
+			return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store {@link metadata}. */
+	setMetadata(data) {
+		this.metadata = JSON.stringify(data ?? {});
+	}
+	/**
+	* Transition `draft → active`. Validates the terms first so no active
+	* policy can carry malformed window/mode/eligibility values.
+	*/
+	activate() {
+		if (this.status !== "draft") throw new Error(`AttributionPolicy ${this.policyKey}@${this.version}: cannot activate from status '${this.status}'`);
+		validateAttributionPolicyTerms(this);
+		this.status = "active";
+	}
+	/** Transition `active → superseded` (a newer version took over). */
+	supersede() {
+		if (this.status !== "active") throw new Error(`AttributionPolicy ${this.policyKey}@${this.version}: cannot supersede from status '${this.status}'`);
+		this.status = "superseded";
+	}
+	/** Transition `draft | active → retired` (terminal). */
+	retire() {
+		if (this.status !== "draft" && this.status !== "active") throw new Error(`AttributionPolicy ${this.policyKey}@${this.version}: cannot retire from status '${this.status}'`);
+		this.status = "retired";
+	}
+	/**
+	* Save with two guards (CommissionPlan pattern):
+	*
+	* 1. **Status transition** — the about-to-be-written status must be a
+	*    legal edge from the authoritative prior persisted status (re-read
+	*    from the DB so a `create({ id: <existing>, _skipLoad: true })` upsert
+	*    can't sidestep the guard).
+	* 2. **Frozen policy identity** — once the row has been saved non-draft,
+	*    every policy-defining field must match the captured snapshot. Amend
+	*    by inserting a new version instead.
+	*/
+	async save() {
+		const prior = await this.resolvePriorStatus();
+		this.assertStatusTransition(prior);
+		this.assertFrozenIdentityUnchanged();
+		await this.assertNaturalKeyNotTaken();
+		if (this.status === "active") validateAttributionPolicyTerms(this);
+		const result = await super.save();
+		loadedPolicyStatus.set(this, this.status);
+		if (this.status !== "draft" && !frozenPolicySnapshot.has(this)) frozenPolicySnapshot.set(this, this.serializeFrozenSnapshot());
+		return result;
+	}
+	/**
+	* Refuse a save whose `(tenantId, policyKey, version)` natural key
+	* already belongs to a DIFFERENT row — the frozen-identity guard is
+	* instance-local, so a fresh instance would otherwise upsert over the
+	* persisted policy (rewriting attribution rules and rotating the row
+	* id). Edit drafts by hydrating them; change terms with
+	* `AttributionPolicyCollection.createAmendment()`.
+	*/
+	async assertNaturalKeyNotTaken() {
+		if (!this.policyKey) return;
+		try {
+			const res = await this.db.query(`SELECT id, tenant_id FROM ${this.tableName} WHERE policy_key = $1 AND version = $2`, this.policyKey, this.version);
+			if ((Array.isArray(res) ? res : res.rows ?? []).find((row) => (row.tenant_id ?? null) === (this.tenantId ?? null) && row.id !== this.id)) throw new Error(`AttributionPolicy ${this.policyKey}@${this.version}: this version already exists for the tenant \u2014 policy versions are immutable records. Hydrate the existing row to edit a draft, or create new terms with AttributionPolicyCollection.createAmendment().`);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("immutable")) throw error;
+		}
+	}
+	/**
+	* Resolve the AUTHORITATIVE prior status from the database; fall back to
+	* the loaded-status WeakMap only when the DB is unavailable. `undefined`
+	* means no persisted row exists (genuinely new).
+	*/
+	async resolvePriorStatus() {
+		if (this.id) try {
+			const row = await this.db.get(this.tableName, { id: this.id });
+			if (row && row.status != null) return row.status;
+		} catch {}
+		return loadedPolicyStatus.get(this);
+	}
+	assertStatusTransition(prior) {
+		if (prior === void 0) return;
+		if (prior === this.status) return;
+		if (!(POLICY_STATUS_TRANSITIONS[prior] ?? []).includes(this.status)) throw new Error(`AttributionPolicy ${this.policyKey}@${this.version}: illegal status transition '${prior}' \u2192 '${this.status}'. Use activate() / supersede() / retire().`);
+	}
+	assertFrozenIdentityUnchanged() {
+		const captured = frozenPolicySnapshot.get(this);
+		if (!captured) return;
+		if (captured !== this.serializeFrozenSnapshot()) throw new Error(`AttributionPolicy ${this.policyKey}@${this.version}: the policy-defining fields are immutable once the policy has been active. Create an amendment (AttributionPolicyCollection.createAmendment) instead of editing this version.`);
+	}
+	serializeFrozenSnapshot() {
+		return JSON.stringify({
+			policyKey: this.policyKey,
+			version: this.version,
+			windowDays: this.windowDays,
+			creditMode: this.creditMode,
+			conflictBehavior: this.conflictBehavior,
+			allowSelfReferral: Boolean(this.allowSelfReferral),
+			allowExistingClients: Boolean(this.allowExistingClients),
+			eligibleServices: this.eligibleServices,
+			eligibleCampaigns: this.eligibleCampaigns,
+			eligibleRegions: this.eligibleRegions,
+			effectiveFrom: this.effectiveFrom ? this.effectiveFrom.toISOString() : null
+		});
+	}
+	static parseStringArray(raw) {
+		if (!raw) return [];
+		try {
+			const parsed = JSON.parse(raw);
+			return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
+		} catch {
+			return [];
+		}
+	}
+	static coerceDate(value) {
+		if (value == null) return null;
+		if (value instanceof Date) return value;
+		if (typeof value === "number" || typeof value === "string") {
+			const d = new Date(value);
+			return Number.isNaN(d.getTime()) ? null : d;
+		}
+		return null;
+	}
+};
+__decorateClass$7([tenantId({ nullable: true })], AttributionPolicy.prototype, "tenantId", 2);
+__decorateClass$7([field({ required: true })], AttributionPolicy.prototype, "policyKey", 2);
+AttributionPolicy = __decorateClass$7([TenantScoped({ mode: "optional" }), smrt({
+	conflictColumns: [
+		"tenant_id",
+		"policy_key",
+		"version"
+	],
+	api: { include: [
+		"list",
+		"get",
+		"create"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: true
+})], AttributionPolicy);
+//#endregion
+//#region src/referrals/collections/AttributionPolicyCollection.ts
+var AttributionPolicyCollection = class extends SmrtCollection {
+	static _itemClass = AttributionPolicy;
+	/** Every version of a policy, newest version first. */
+	async findByPolicyKey(policyKey) {
+		return await this.list({
+			where: { policyKey },
+			orderBy: "version DESC"
+		});
+	}
+	/** Policies by status. */
+	async findByStatus(status) {
+		return await this.list({
+			where: { status },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* The highest ACTIVE version of a policy already IN EFFECT at `at`, or
+	* `null` when none is. This is what `AttributionService.resolve()` loads
+	* when the caller doesn't pin a version. A future-dated amendment can be
+	* activated ahead of its effective date without governing attributions
+	* resolved before it takes effect (`effectiveFrom: null` = effective
+	* immediately).
+	*/
+	async latestActiveByKey(policyKey, at = /* @__PURE__ */ new Date(), tenantId) {
+		const inEffect = (await this.list({
+			where: {
+				policyKey,
+				status: "active"
+			},
+			orderBy: "version DESC"
+		})).filter((policy) => policy.effectiveFrom === null || policy.effectiveFrom <= at);
+		if (tenantId === void 0) return inEffect[0] ?? null;
+		return inEffect.find((policy) => policy.tenantId === tenantId) ?? inEffect.find((policy) => policy.tenantId === null) ?? null;
+	}
+	/**
+	* Create an amendment: insert a new DRAFT row with
+	* `version = max(existing versions) + 1`, copying the latest existing
+	* version's fields and then applying `changes`. The source version is not
+	* touched — activate the draft (and supersede the prior active version)
+	* as a separate, explicit step.
+	*
+	* Throws when no version of `policyKey` exists (nothing to amend — use
+	* `create` for a brand-new policy).
+	*/
+	async createAmendment(policyKey, changes = {}) {
+		const latest = (await this.findByPolicyKey(policyKey))[0];
+		if (!latest) throw new Error(`AttributionPolicyCollection.createAmendment: no versions exist for policy key '${policyKey}' \u2014 create the policy first`);
+		return await this.create({
+			tenantId: latest.tenantId,
+			policyKey,
+			version: latest.version + 1,
+			status: "draft",
+			windowDays: changes.windowDays ?? latest.windowDays,
+			creditMode: changes.creditMode ?? latest.creditMode,
+			conflictBehavior: changes.conflictBehavior ?? latest.conflictBehavior,
+			allowSelfReferral: changes.allowSelfReferral ?? latest.allowSelfReferral,
+			allowExistingClients: changes.allowExistingClients ?? latest.allowExistingClients,
+			eligibleServices: changes.eligibleServices !== void 0 ? JSON.stringify(changes.eligibleServices) : latest.eligibleServices,
+			eligibleCampaigns: changes.eligibleCampaigns !== void 0 ? JSON.stringify(changes.eligibleCampaigns) : latest.eligibleCampaigns,
+			eligibleRegions: changes.eligibleRegions !== void 0 ? JSON.stringify(changes.eligibleRegions) : latest.eligibleRegions,
+			effectiveFrom: changes.effectiveFrom !== void 0 ? changes.effectiveFrom : latest.effectiveFrom,
+			metadata: changes.metadata !== void 0 ? JSON.stringify(changes.metadata) : latest.metadata
+		});
+	}
+};
+//#endregion
+//#region src/referrals/models/ReferralAgreement.ts
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __decorateClass$6 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$6(target, key, result);
+	return result;
+};
+var AGREEMENT_STATUS_TRANSITIONS = {
+	draft: ["active", "terminated"],
+	active: ["superseded", "terminated"],
+	superseded: [],
+	terminated: []
+};
+var loadedAgreementStatus = /* @__PURE__ */ new WeakMap();
+var frozenAgreementSnapshot = /* @__PURE__ */ new WeakMap();
+var ReferralAgreement = class extends SmrtObject {
+	tenantId = null;
+	referrerId = "";
+	programId = "";
+	/** Monotonic version within `(referrerId, programId)`. */
+	version = 1;
+	/**
+	* Lifecycle status — see the module transition map. Mutate via
+	* {@link activate} / {@link supersede} / {@link terminate}.
+	*/
+	status = "draft";
+	/** Start of the effective window (`null` = effective immediately). */
+	effectiveFrom = null;
+	/**
+	* End of the effective window (`null` = open-ended). Deliberately NOT
+	* frozen: end-dating an active agreement is a legitimate operation.
+	*/
+	effectiveTo = null;
+	/**
+	* The commissions-module CommissionPlan key these terms bind. Required to
+	* activate.
+	*/
+	commissionPlanKey = "";
+	/**
+	* Pinned plan version. `0` (default) means "resolve the latest ACTIVE
+	* version at qualification time and pin it in the ReferralTermSnapshot";
+	* `> 0` pins a specific version now.
+	*/
+	commissionPlanVersion = 0;
+	/**
+	* Clearing window in days applied to commissions earned under these
+	* terms (refund/chargeback holdback). Frozen into every snapshot.
+	*/
+	clearingDays = 0;
+	/** How earned commissions are approved downstream. */
+	approvalMode = "manual";
+	contractRef = "";
+	/** URL of the executed agreement artifact (e-signature PDF, …). */
+	executedArtifactUrl = "";
+	/** Content hash of the executed artifact for tamper evidence. */
+	executedArtifactHash = "";
+	/**
+	* Acceptance evidence as a JSON object string (click-through record, IP,
+	* timestamp, signer, …). Use
+	* {@link getAcceptanceEvidence}/{@link setAcceptanceEvidence}.
+	*/
+	acceptanceEvidence = "{}";
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.referrerId !== void 0) this.referrerId = options.referrerId;
+		if (options.programId !== void 0) this.programId = options.programId;
+		if (options.version !== void 0) this.version = options.version;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.effectiveFrom !== void 0) this.effectiveFrom = ReferralAgreement.coerceDate(options.effectiveFrom);
+		if (options.effectiveTo !== void 0) this.effectiveTo = ReferralAgreement.coerceDate(options.effectiveTo);
+		if (options.commissionPlanKey !== void 0) this.commissionPlanKey = options.commissionPlanKey;
+		if (options.commissionPlanVersion !== void 0) this.commissionPlanVersion = options.commissionPlanVersion;
+		if (options.clearingDays !== void 0) this.clearingDays = options.clearingDays;
+		if (options.approvalMode !== void 0) this.approvalMode = options.approvalMode;
+		if (options.contractRef !== void 0) this.contractRef = options.contractRef;
+		if (options.executedArtifactUrl !== void 0) this.executedArtifactUrl = options.executedArtifactUrl;
+		if (options.executedArtifactHash !== void 0) this.executedArtifactHash = options.executedArtifactHash;
+		if (options.acceptanceEvidence !== void 0) this.acceptanceEvidence = options.acceptanceEvidence;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/**
+	* Re-coerce date fields after the framework reapplies raw option values,
+	* record the loaded status for the transition guard, and capture the
+	* frozen terms snapshot when the row arrived already non-draft
+	* (superseded / terminated history can't be rewritten either).
+	*/
+	async initialize() {
+		await super.initialize();
+		this.effectiveFrom = ReferralAgreement.coerceDate(this.effectiveFrom);
+		this.effectiveTo = ReferralAgreement.coerceDate(this.effectiveTo);
+		if (await this.isSaved()) {
+			loadedAgreementStatus.set(this, this.status);
+			if (this.status !== "draft") frozenAgreementSnapshot.set(this, this.serializeFrozenTerms());
+		}
+		return this;
+	}
+	isDraft() {
+		return this.status === "draft";
+	}
+	isActive() {
+		return this.status === "active";
+	}
+	/**
+	* Whether the effective window contains `at` (`effectiveFrom` null =
+	* always started; `effectiveTo` null = open-ended). Status is NOT part of
+	* this check — combine with {@link isActive}.
+	*/
+	isEffectiveAt(at) {
+		if (this.effectiveFrom && at.getTime() < this.effectiveFrom.getTime()) return false;
+		if (this.effectiveTo && at.getTime() > this.effectiveTo.getTime()) return false;
+		return true;
+	}
+	/** Parse {@link acceptanceEvidence}; returns `{}` on malformed content. */
+	getAcceptanceEvidence() {
+		if (!this.acceptanceEvidence) return {};
+		try {
+			const parsed = JSON.parse(this.acceptanceEvidence);
+			return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store {@link acceptanceEvidence}. */
+	setAcceptanceEvidence(evidence) {
+		this.acceptanceEvidence = JSON.stringify(evidence ?? {});
+	}
+	/** Parse {@link metadata}; returns `{}` on malformed content. */
+	getMetadata() {
+		if (!this.metadata) return {};
+		try {
+			const parsed = JSON.parse(this.metadata);
+			return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store {@link metadata}. */
+	setMetadata(data) {
+		this.metadata = JSON.stringify(data ?? {});
+	}
+	/**
+	* Transition `draft → active`. Requires a non-empty
+	* {@link commissionPlanKey} — an agreement without bound terms cannot
+	* govern qualification.
+	*/
+	activate() {
+		if (this.status !== "draft") throw new Error(`ReferralAgreement ${this.referrerId}/${this.programId}@${this.version}: cannot activate from status '${this.status}'`);
+		if (!this.commissionPlanKey) throw new Error(`ReferralAgreement ${this.referrerId}/${this.programId}@${this.version}: commissionPlanKey is required to activate`);
+		this.status = "active";
+	}
+	/** Transition `active → superseded` (a newer version took over). */
+	supersede() {
+		if (this.status !== "active") throw new Error(`ReferralAgreement ${this.referrerId}/${this.programId}@${this.version}: cannot supersede from status '${this.status}'`);
+		this.status = "superseded";
+	}
+	/** Transition `draft | active → terminated` (terminal). */
+	terminate() {
+		if (this.status !== "draft" && this.status !== "active") throw new Error(`ReferralAgreement ${this.referrerId}/${this.programId}@${this.version}: cannot terminate from status '${this.status}'`);
+		this.status = "terminated";
+	}
+	/**
+	* Save with two guards (CommissionPlan pattern):
+	*
+	* 1. **Status transition** — the about-to-be-written status must be a
+	*    legal edge from the authoritative prior persisted status.
+	* 2. **Frozen terms** — once the row has been saved non-draft, the terms
+	*    fields must match the captured snapshot. Amend by inserting a new
+	*    version instead.
+	*
+	* Activating saves also re-require {@link commissionPlanKey}.
+	*/
+	async save() {
+		const prior = await this.resolvePriorStatus();
+		this.assertStatusTransition(prior);
+		this.assertFrozenTermsUnchanged();
+		await this.assertNaturalKeyNotTaken();
+		if (this.status === "active" && !this.commissionPlanKey) throw new Error(`ReferralAgreement ${this.referrerId}/${this.programId}@${this.version}: commissionPlanKey is required while active`);
+		const result = await super.save();
+		loadedAgreementStatus.set(this, this.status);
+		if (this.status !== "draft" && !frozenAgreementSnapshot.has(this)) frozenAgreementSnapshot.set(this, this.serializeFrozenTerms());
+		return result;
+	}
+	/**
+	* Refuse a save whose `(referrerId, programId, version)` natural key
+	* already belongs to a DIFFERENT row — the frozen-terms guard is
+	* instance-local, so a fresh instance would otherwise upsert over the
+	* persisted agreement (replacing legally frozen referral terms without
+	* an amendment, and rotating the row id). Edit drafts by hydrating
+	* them; change terms with
+	* `ReferralAgreementCollection.createAmendment()`.
+	*/
+	async assertNaturalKeyNotTaken() {
+		if (!this.referrerId || !this.programId) return;
+		try {
+			const res = await this.db.query(`SELECT id FROM ${this.tableName} WHERE referrer_id = $1 AND program_id = $2 AND version = $3`, this.referrerId, this.programId, this.version);
+			if ((Array.isArray(res) ? res : res.rows ?? []).find((row) => row.id !== this.id)) throw new Error(`ReferralAgreement ${this.referrerId}/${this.programId}@${this.version}: this version already exists \u2014 agreement versions are immutable records. Hydrate the existing row to edit a draft, or create new terms with ReferralAgreementCollection.createAmendment().`);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("immutable")) throw error;
+		}
+	}
+	async resolvePriorStatus() {
+		if (this.id) try {
+			const row = await this.db.get(this.tableName, { id: this.id });
+			if (row && row.status != null) return row.status;
+		} catch {}
+		return loadedAgreementStatus.get(this);
+	}
+	assertStatusTransition(prior) {
+		if (prior === void 0) return;
+		if (prior === this.status) return;
+		if (!(AGREEMENT_STATUS_TRANSITIONS[prior] ?? []).includes(this.status)) throw new Error(`ReferralAgreement ${this.referrerId}/${this.programId}@${this.version}: illegal status transition '${prior}' \u2192 '${this.status}'. Use activate() / supersede() / terminate().`);
+	}
+	assertFrozenTermsUnchanged() {
+		const captured = frozenAgreementSnapshot.get(this);
+		if (!captured) return;
+		if (captured !== this.serializeFrozenTerms()) throw new Error(`ReferralAgreement ${this.referrerId}/${this.programId}@${this.version}: terms are immutable once the agreement has been active. Create an amendment (ReferralAgreementCollection.createAmendment) instead of editing this version.`);
+	}
+	serializeFrozenTerms() {
+		return JSON.stringify({
+			referrerId: this.referrerId,
+			programId: this.programId,
+			version: this.version,
+			commissionPlanKey: this.commissionPlanKey,
+			commissionPlanVersion: this.commissionPlanVersion,
+			clearingDays: this.clearingDays,
+			approvalMode: this.approvalMode,
+			effectiveFrom: this.effectiveFrom ? this.effectiveFrom.toISOString() : null
+		});
+	}
+	static coerceDate(value) {
+		if (value == null) return null;
+		if (value instanceof Date) return value;
+		if (typeof value === "number" || typeof value === "string") {
+			const d = new Date(value);
+			return Number.isNaN(d.getTime()) ? null : d;
+		}
+		return null;
+	}
+};
+__decorateClass$6([tenantId({ nullable: true })], ReferralAgreement.prototype, "tenantId", 2);
+__decorateClass$6([foreignKey("Referrer", { required: true })], ReferralAgreement.prototype, "referrerId", 2);
+__decorateClass$6([foreignKey("ReferralProgram", { required: true })], ReferralAgreement.prototype, "programId", 2);
+__decorateClass$6([crossPackageRef("@happyvertical/smrt-commerce:Contract")], ReferralAgreement.prototype, "contractRef", 2);
+ReferralAgreement = __decorateClass$6([TenantScoped({ mode: "optional" }), smrt({
+	conflictColumns: [
+		"referrer_id",
+		"program_id",
+		"version"
+	],
+	api: { include: [
+		"list",
+		"get",
+		"create"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: true
+})], ReferralAgreement);
+//#endregion
+//#region src/referrals/collections/ReferralAgreementCollection.ts
+var ReferralAgreementCollection = class extends SmrtCollection {
+	static _itemClass = ReferralAgreement;
+	/** Every version of one referrer+program agreement, newest version first. */
+	async findByReferrerAndProgram(referrerId, programId) {
+		return await this.list({
+			where: {
+				referrerId,
+				programId
+			},
+			orderBy: "version DESC"
+		});
+	}
+	/**
+	* The agreement governing `(referrerId, programId)` at instant `at`
+	* (default now): status `active` AND effective window containing `at`
+	* (`effectiveFrom` null = always started; `effectiveTo` null =
+	* open-ended). When several active versions overlap — transitional states
+	* during amendment activation — the highest version wins. `null` when
+	* nothing governs.
+	*/
+	async activeFor(referrerId, programId, at = /* @__PURE__ */ new Date()) {
+		return (await this.list({
+			where: {
+				referrerId,
+				programId,
+				status: "active"
+			},
+			orderBy: "version DESC"
+		})).find((agreement) => agreement.isEffectiveAt(at)) ?? null;
+	}
+	/**
+	* Create an amendment: insert a new DRAFT row with
+	* `version = max(existing versions) + 1`, copying the latest existing
+	* version's fields and then applying `changes`. The source version is not
+	* touched — activate the draft (and supersede the prior active version)
+	* as a separate, explicit step.
+	*
+	* Throws when no version exists for the pair (nothing to amend — use
+	* `create` for a brand-new agreement).
+	*/
+	async createAmendment(referrerId, programId, changes = {}) {
+		const latest = (await this.findByReferrerAndProgram(referrerId, programId))[0];
+		if (!latest) throw new Error(`ReferralAgreementCollection.createAmendment: no versions exist for referrer '${referrerId}' in program '${programId}' \u2014 create the agreement first`);
+		return await this.create({
+			tenantId: latest.tenantId,
+			referrerId,
+			programId,
+			version: latest.version + 1,
+			status: "draft",
+			commissionPlanKey: changes.commissionPlanKey ?? latest.commissionPlanKey,
+			commissionPlanVersion: changes.commissionPlanVersion ?? latest.commissionPlanVersion,
+			clearingDays: changes.clearingDays ?? latest.clearingDays,
+			approvalMode: changes.approvalMode ?? latest.approvalMode,
+			effectiveFrom: changes.effectiveFrom !== void 0 ? changes.effectiveFrom : latest.effectiveFrom,
+			effectiveTo: changes.effectiveTo !== void 0 ? changes.effectiveTo : latest.effectiveTo,
+			contractRef: changes.contractRef ?? latest.contractRef,
+			executedArtifactUrl: changes.executedArtifactUrl ?? latest.executedArtifactUrl,
+			executedArtifactHash: changes.executedArtifactHash ?? latest.executedArtifactHash,
+			acceptanceEvidence: changes.acceptanceEvidence !== void 0 ? JSON.stringify(changes.acceptanceEvidence) : latest.acceptanceEvidence,
+			metadata: changes.metadata !== void 0 ? JSON.stringify(changes.metadata) : latest.metadata
+		});
+	}
+};
+//#endregion
+//#region src/referrals/models/Referral.ts
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$5(target, key, result);
+	return result;
+};
+var REFERRAL_STATUS_TRANSITIONS = {
+	pending: [
+		"attributed",
+		"under_review",
+		"disqualified",
+		"expired"
+	],
+	under_review: ["attributed", "disqualified"],
+	attributed: [
+		"qualified",
+		"disqualified",
+		"expired"
+	],
+	qualified: ["disqualified"],
+	disqualified: [],
+	expired: []
+};
+var loadedReferralStatus = /* @__PURE__ */ new WeakMap();
+var Referral = class extends SmrtObject {
+	tenantId = null;
+	referrerId = "";
+	programId = "";
+	/** AttributionPolicy key resolved at attribution ('' until attributed). */
+	policyKey = "";
+	/** AttributionPolicy version resolved at attribution (0 until attributed). */
+	policyVersion = 0;
+	/**
+	* Lifecycle status — see the module transition map. Mutate via the
+	* transition methods; the save-time guard rejects illegal edges.
+	*/
+	status = "pending";
+	/**
+	* Generic qualifying target: what the introduction became/points at —
+	* `('lead', <id>)`, `('opportunity', <id>)`, `('client', <id>)`,
+	* `('subscription', <id>)`, … This module attaches no semantics to it.
+	*/
+	targetKind = "";
+	/** Identifier within the {@link targetKind} namespace. */
+	targetId = "";
+	/**
+	* Credit share (0–1) this referral carries. `1.0` for sole attribution;
+	* split attribution creates sibling Referrals whose fractions sum to 1.0
+	* sharing one {@link splitGroupId}. Flows into Commission
+	* `shareFraction` at earning time.
+	*/
+	creditFraction = 1;
+	/** Groups the sibling referrals of one split. Empty for unsplit rows. */
+	splitGroupId = "";
+	primaryTouchId = "";
+	/** When the referral was attributed. */
+	attributedAt = null;
+	/** When the referral was qualified. */
+	qualifiedAt = null;
+	/**
+	* When an attributed-but-unqualified referral lapses. Stamped at
+	* attribution (`attributedAt + policy.windowDays`); enforced by
+	* `ReferralCollection.sweepExpired()`.
+	*/
+	expiresAt = null;
+	/**
+	* The ReferralTermSnapshot frozen at qualification ('' until qualified).
+	* Requalification repoints this at a NEW snapshot; old snapshots remain
+	* as history.
+	*
+	* Deliberately a PLAIN string reference (not `@foreignKey`): the
+	* snapshot's own `referralId` FK carries the relationship, and declaring
+	* both directions would put a cycle in the model graph (breaking the
+	* registry's topological initialization order). Services fetch the
+	* snapshot by id explicitly.
+	*/
+	snapshotId = "";
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.referrerId !== void 0) this.referrerId = options.referrerId;
+		if (options.programId !== void 0) this.programId = options.programId;
+		if (options.policyKey !== void 0) this.policyKey = options.policyKey;
+		if (options.policyVersion !== void 0) this.policyVersion = options.policyVersion;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.targetKind !== void 0) this.targetKind = options.targetKind;
+		if (options.targetId !== void 0) this.targetId = options.targetId;
+		if (options.creditFraction !== void 0) this.creditFraction = options.creditFraction;
+		if (options.splitGroupId !== void 0) this.splitGroupId = options.splitGroupId;
+		if (options.primaryTouchId !== void 0) this.primaryTouchId = options.primaryTouchId;
+		if (options.attributedAt !== void 0) this.attributedAt = Referral.coerceDate(options.attributedAt);
+		if (options.qualifiedAt !== void 0) this.qualifiedAt = Referral.coerceDate(options.qualifiedAt);
+		if (options.expiresAt !== void 0) this.expiresAt = Referral.coerceDate(options.expiresAt);
+		if (options.snapshotId !== void 0) this.snapshotId = options.snapshotId;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/**
+	* Re-coerce date fields after the framework reapplies raw option values
+	* and record the loaded status for the save-time transition guard.
+	*/
+	async initialize() {
+		await super.initialize();
+		this.attributedAt = Referral.coerceDate(this.attributedAt);
+		this.qualifiedAt = Referral.coerceDate(this.qualifiedAt);
+		this.expiresAt = Referral.coerceDate(this.expiresAt);
+		if (await this.isSaved()) loadedReferralStatus.set(this, this.status);
+		return this;
+	}
+	isAttributed() {
+		return this.status === "attributed";
+	}
+	isQualified() {
+		return this.status === "qualified";
+	}
+	/** Whether the referral sits in a terminal status. */
+	isTerminal() {
+		return this.status === "disqualified" || this.status === "expired";
+	}
+	/** Parse {@link metadata}; returns `{}` on malformed content. */
+	getMetadata() {
+		if (!this.metadata) return {};
+		try {
+			const parsed = JSON.parse(this.metadata);
+			return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store {@link metadata}. */
+	setMetadata(data) {
+		this.metadata = JSON.stringify(data ?? {});
+	}
+	/** Transition `pending → under_review` (conflict parked for humans). */
+	markUnderReview() {
+		if (this.status !== "pending") throw new Error(`Referral ${this.id ?? "<new>"}: cannot move to under_review from status '${this.status}'`);
+		this.status = "under_review";
+	}
+	/**
+	* Transition `pending | under_review → attributed` and stamp
+	* {@link attributedAt}.
+	*/
+	markAttributed(at = /* @__PURE__ */ new Date()) {
+		if (this.status !== "pending" && this.status !== "under_review") throw new Error(`Referral ${this.id ?? "<new>"}: cannot attribute from status '${this.status}'`);
+		this.status = "attributed";
+		this.attributedAt = at;
+	}
+	/** Transition `attributed → qualified` and stamp {@link qualifiedAt}. */
+	markQualified(at = /* @__PURE__ */ new Date()) {
+		if (this.status !== "attributed") throw new Error(`Referral ${this.id ?? "<new>"}: cannot qualify from status '${this.status}'`);
+		this.status = "qualified";
+		this.qualifiedAt = at;
+	}
+	/**
+	* Transition to `disqualified` (terminal). Legal from every non-terminal
+	* status — including `qualified` (the rare clawback path).
+	*/
+	disqualify() {
+		if (this.isTerminal()) throw new Error(`Referral ${this.id ?? "<new>"}: cannot disqualify from terminal status '${this.status}'`);
+		this.status = "disqualified";
+	}
+	/** Transition `pending | attributed → expired` (terminal). */
+	markExpired() {
+		if (this.status !== "pending" && this.status !== "attributed") throw new Error(`Referral ${this.id ?? "<new>"}: cannot expire from status '${this.status}'`);
+		this.status = "expired";
+	}
+	/**
+	* Validate the status transition before persisting, then save. A forged
+	* `status` (e.g. un-expiring a referral or skipping straight to
+	* qualified) is rejected regardless of how the instance was constructed.
+	*/
+	async save() {
+		const prior = await this.resolvePriorStatus();
+		this.assertStatusTransition(prior);
+		const result = await super.save();
+		loadedReferralStatus.set(this, this.status);
+		return result;
+	}
+	/**
+	* Resolve the AUTHORITATIVE prior status from the database; fall back to
+	* the loaded-status WeakMap only when the DB is unavailable (commerce
+	* pattern — an upsert via `create({ id, _skipLoad: true })` can't
+	* sidestep the guard).
+	*/
+	async resolvePriorStatus() {
+		if (this.id) try {
+			const row = await this.db.get(this.tableName, { id: this.id });
+			if (row && row.status != null) return row.status;
+		} catch {}
+		return loadedReferralStatus.get(this);
+	}
+	assertStatusTransition(prior) {
+		if (prior === void 0) return;
+		if (prior === this.status) return;
+		if (!(REFERRAL_STATUS_TRANSITIONS[prior] ?? []).includes(this.status)) throw new Error(`Referral ${this.id ?? "<new>"}: illegal status transition '${prior}' \u2192 '${this.status}'.`);
+	}
+	static coerceDate(value) {
+		if (value == null) return null;
+		if (value instanceof Date) return value;
+		if (typeof value === "number" || typeof value === "string") {
+			const d = new Date(value);
+			return Number.isNaN(d.getTime()) ? null : d;
+		}
+		return null;
+	}
+};
+__decorateClass$5([tenantId({ nullable: true })], Referral.prototype, "tenantId", 2);
+__decorateClass$5([foreignKey("Referrer", { required: true })], Referral.prototype, "referrerId", 2);
+__decorateClass$5([foreignKey("ReferralProgram", { required: true })], Referral.prototype, "programId", 2);
+__decorateClass$5([foreignKey("ReferralTouch")], Referral.prototype, "primaryTouchId", 2);
+Referral = __decorateClass$5([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: true
+})], Referral);
+//#endregion
+//#region src/referrals/collections/ReferralCollection.ts
+var ReferralCollection = class extends SmrtCollection {
+	static _itemClass = Referral;
+	/** All referrals credited to a referrer, newest first. */
+	async findByReferrer(referrerId) {
+		return await this.list({
+			where: { referrerId },
+			orderBy: "created_at DESC"
+		});
+	}
+	/** All referrals pointing at one qualifying target, newest first. */
+	async findByTarget(targetKind, targetId) {
+		return await this.list({
+			where: {
+				targetKind,
+				targetId
+			},
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* QUALIFIED referrals for one target — what
+	* `ReferralCommissionService.processEarningEvent` resolves when given a
+	* target instead of explicit referral ids.
+	*/
+	async findQualifiedByTarget(targetKind, targetId) {
+		return await this.list({
+			where: {
+				targetKind,
+				targetId,
+				status: "qualified"
+			},
+			orderBy: "created_at ASC"
+		});
+	}
+	/**
+	* Expire lapsed attributions: every `attributed` referral whose
+	* `expiresAt` is set and `<= now` transitions to `expired` and is saved.
+	* Referrals without an `expiresAt` never lapse.
+	*
+	* @returns The referrals expired by this sweep.
+	*/
+	async sweepExpired(now = /* @__PURE__ */ new Date()) {
+		const attributed = await this.list({
+			where: { status: "attributed" },
+			orderBy: "created_at ASC"
+		});
+		const swept = [];
+		for (const referral of attributed) {
+			const expiresAt = referral.expiresAt;
+			if (expiresAt === null || expiresAt.getTime() > now.getTime()) continue;
+			referral.markExpired();
+			await referral.save();
+			swept.push(referral);
+		}
+		return swept;
+	}
+};
+//#endregion
+//#region src/referrals/models/ReferralLink.ts
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$4(target, key, result);
+	return result;
+};
+function assertHttpTargetUrl(targetUrl) {
+	let parsed;
+	try {
+		parsed = new URL(targetUrl);
+	} catch {
+		throw new Error(`ReferralLink targetUrl must be an absolute http(s) URL \u2014 got '${targetUrl}'`);
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`ReferralLink targetUrl must use http or https \u2014 got '${parsed.protocol}'`);
+}
+var ReferralLink = class extends SmrtObject {
+	tenantId = null;
+	referrerId = "";
+	programId = "";
+	code = "";
+	/**
+	* Optional destination URL the shared link forwards to. Must be an
+	* absolute http/https URL when non-empty (validated at save time).
+	*/
+	targetUrl = "";
+	/** Human-readable label for the referrer's own bookkeeping. */
+	label = "";
+	/** `active` (default) accepts clicks; `disabled` refuses them. */
+	status = "active";
+	/** Number of recorded clicks (incremented by `recordClick`). */
+	clickCount = 0;
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.referrerId !== void 0) this.referrerId = options.referrerId;
+		if (options.programId !== void 0) this.programId = options.programId;
+		if (options.code !== void 0) this.code = options.code;
+		if (options.targetUrl !== void 0) this.targetUrl = options.targetUrl;
+		if (options.label !== void 0) this.label = options.label;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.clickCount !== void 0) this.clickCount = options.clickCount;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Whether the link currently accepts clicks. */
+	isActive() {
+		return this.status === "active";
+	}
+	/** Parse the metadata JSON string; returns `{}` on malformed content. */
+	getMetadata() {
+		try {
+			const parsed = JSON.parse(this.metadata);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+			return {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store the metadata object. */
+	setMetadata(metadata) {
+		this.metadata = JSON.stringify(metadata);
+	}
+	/**
+	* Save with two guards:
+	*
+	* - a non-empty {@link targetUrl} must be an absolute http/https URL
+	*   regardless of which write path set it;
+	* - the {@link code} must not belong to a DIFFERENT persisted link. Codes
+	*   are the upsert natural key and they are public — without this check a
+	*   generated-surface `create` carrying an existing code would silently
+	*   UPSERT over that link (rewriting its referrer/program/target: a
+	*   referral-code hijack). Mint codes through
+	*   `ReferralLinkCollection.createWithUniqueCode()`.
+	*/
+	async save() {
+		if (this.targetUrl) assertHttpTargetUrl(this.targetUrl);
+		if (this.code) try {
+			const row = await this.db.get(this.tableName, { code: this.code });
+			if (row && row.id !== this.id) throw new Error(`ReferralLink (code '${this.code}'): this code already belongs to another link \u2014 referral codes are unique and cannot be taken over. Mint links through ReferralLinkCollection.createWithUniqueCode().`);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("cannot be taken over")) throw error;
+		}
+		return await super.save();
+	}
+};
+__decorateClass$4([tenantId({ nullable: true })], ReferralLink.prototype, "tenantId", 2);
+__decorateClass$4([foreignKey("Referrer", { required: true })], ReferralLink.prototype, "referrerId", 2);
+__decorateClass$4([foreignKey("ReferralProgram", { required: true })], ReferralLink.prototype, "programId", 2);
+__decorateClass$4([field({ required: true })], ReferralLink.prototype, "code", 2);
+ReferralLink = __decorateClass$4([TenantScoped({ mode: "optional" }), smrt({
+	conflictColumns: ["code"],
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: [
+		"list",
+		"get",
+		"create"
+	] },
+	cli: true
+})], ReferralLink);
+//#endregion
+//#region src/referrals/models/ReferralTouch.ts
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$3(target, key, result);
+	return result;
+};
+var ReferralTouch = class extends SmrtObject {
+	tenantId = null;
+	linkId = "";
+	/** The share code involved, when the touch came through a code/link. */
+	code = "";
+	referrerId = "";
+	programId = "";
+	/** What kind of interaction this evidence records. */
+	kind = "click";
+	/**
+	* Prospect identity when known — a generic `(subjectKind, subjectId)`
+	* pair (e.g. `('lead', <id>)`, `('email', 'a@b.test')`). Attribution
+	* matches touches to a resolution's subject and/or target through these.
+	*/
+	subjectKind = "";
+	/** Identifier within the {@link subjectKind} namespace. */
+	subjectId = "";
+	/** When the interaction occurred (not when it was ingested). */
+	occurredAt = /* @__PURE__ */ new Date();
+	/**
+	* Evidence payload as a JSON object string (the code/link/url for clicks,
+	* actor + reason for manual assignments, …). Use
+	* {@link getEvidence}/{@link setEvidence}.
+	*/
+	evidence = "{}";
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.linkId !== void 0) this.linkId = options.linkId;
+		if (options.code !== void 0) this.code = options.code;
+		if (options.referrerId !== void 0) this.referrerId = options.referrerId;
+		if (options.programId !== void 0) this.programId = options.programId;
+		if (options.kind !== void 0) this.kind = options.kind;
+		if (options.subjectKind !== void 0) this.subjectKind = options.subjectKind;
+		if (options.subjectId !== void 0) this.subjectId = options.subjectId;
+		if (options.occurredAt !== void 0) this.occurredAt = ReferralTouch.coerceDate(options.occurredAt) ?? /* @__PURE__ */ new Date();
+		if (options.evidence !== void 0) this.evidence = options.evidence;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/**
+	* Re-coerce {@link occurredAt} after the framework reapplies raw option /
+	* hydrated row values (SQLite hands back ISO strings).
+	*/
+	async initialize() {
+		await super.initialize();
+		this.occurredAt = ReferralTouch.coerceDate(this.occurredAt) ?? /* @__PURE__ */ new Date();
+		return this;
+	}
+	/** Parse {@link evidence}; returns `{}` on empty/invalid JSON. */
+	getEvidence() {
+		if (!this.evidence) return {};
+		try {
+			const parsed = JSON.parse(this.evidence);
+			return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store {@link evidence}. */
+	setEvidence(evidence) {
+		this.evidence = JSON.stringify(evidence ?? {});
+	}
+	/** Parse {@link metadata}; returns `{}` on malformed content. */
+	getMetadata() {
+		if (!this.metadata) return {};
+		try {
+			const parsed = JSON.parse(this.metadata);
+			return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store {@link metadata}. */
+	setMetadata(data) {
+		this.metadata = JSON.stringify(data ?? {});
+	}
+	static coerceDate(value) {
+		if (value == null) return null;
+		if (value instanceof Date) return value;
+		if (typeof value === "number" || typeof value === "string") {
+			const d = new Date(value);
+			return Number.isNaN(d.getTime()) ? null : d;
+		}
+		return null;
+	}
+};
+__decorateClass$3([tenantId({ nullable: true })], ReferralTouch.prototype, "tenantId", 2);
+__decorateClass$3([foreignKey("ReferralLink")], ReferralTouch.prototype, "linkId", 2);
+__decorateClass$3([foreignKey("Referrer", { required: true })], ReferralTouch.prototype, "referrerId", 2);
+__decorateClass$3([foreignKey("ReferralProgram")], ReferralTouch.prototype, "programId", 2);
+ReferralTouch = __decorateClass$3([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"create",
+		"list",
+		"get"
+	] },
+	mcp: { include: ["list", "create"] },
+	cli: false
+})], ReferralTouch);
+//#endregion
+//#region src/referrals/collections/ReferralTouchCollection.ts
+var ReferralTouchCollection = class extends SmrtCollection {
+	static _itemClass = ReferralTouch;
+	/** All touches for a referrer, oldest first. */
+	async findByReferrer(referrerId) {
+		return await this.list({
+			where: { referrerId },
+			orderBy: "occurred_at ASC"
+		});
+	}
+	/**
+	* Every touch recorded against one subject identity, oldest first —
+	* attribution's raw candidate stream.
+	*/
+	async findBySubject(subjectKind, subjectId) {
+		return await this.list({
+			where: {
+				subjectKind,
+				subjectId
+			},
+			orderBy: "occurred_at ASC"
+		});
+	}
+	/**
+	* Touches for one subject within one program occurring at or after
+	* `since`, oldest first. The date bound is applied in memory after the
+	* indexed equality filters (sibling-module pattern — the semantics hold
+	* whether an adapter returns ISO strings or Dates).
+	*/
+	async findByTargetWindow(query) {
+		return (await this.list({
+			where: {
+				subjectKind: query.subjectKind,
+				subjectId: query.subjectId,
+				programId: query.programId
+			},
+			orderBy: "occurred_at ASC"
+		})).filter((touch) => touch.occurredAt.getTime() >= query.since.getTime());
+	}
+};
+//#endregion
+//#region src/referrals/collections/ReferralLinkCollection.ts
+var REFERRAL_CODE_LENGTH = 10;
+var REFERRAL_CODE_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+var MAX_CODE_GENERATION_ATTEMPTS = 5;
+function generateReferralCode() {
+	const alphabetSize = 36;
+	const rejectionBound = 256 - 256 % alphabetSize;
+	let code = "";
+	while (code.length < 10) {
+		const bytes = randomBytes(20);
+		for (const byte of bytes) {
+			if (byte >= rejectionBound) continue;
+			code += REFERRAL_CODE_ALPHABET[byte % alphabetSize];
+			if (code.length === 10) break;
+		}
+	}
+	return code;
+}
+var ReferralLinkCollection = class extends SmrtCollection {
+	static _itemClass = ReferralLink;
+	/** All links for a referrer, newest first. */
+	async findByReferrer(referrerId) {
+		return await this.list({
+			where: { referrerId },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Look up a link by its globally unique code (codes are minted lowercase;
+	* the lookup normalizes case so shared codes survive re-typing).
+	*/
+	async findByCode(code) {
+		const normalized = code.trim().toLowerCase();
+		if (!normalized) return null;
+		return (await this.list({
+			where: { code: normalized },
+			limit: 1
+		}))[0] ?? null;
+	}
+	/**
+	* Create a link with a freshly minted, uniqueness-checked code.
+	*
+	* Codes come from `crypto.randomBytes` mapped to
+	* {@link REFERRAL_CODE_LENGTH} lowercase-alphanumeric characters. The
+	* check-then-insert loop retries on collision up to
+	* {@link MAX_CODE_GENERATION_ATTEMPTS} times, then throws — at 36^10
+	* possible codes repeated collisions mean the generator is broken (or a
+	* test seam returns a constant), not bad luck.
+	*/
+	async createWithUniqueCode(input) {
+		if (!input.referrerId || !input.programId) throw new Error("ReferralLinkCollection.createWithUniqueCode requires referrerId and programId");
+		if (input.targetUrl) assertHttpTargetUrl(input.targetUrl);
+		const generate = input.generateCode ?? generateReferralCode;
+		for (let attempt = 0; attempt < 5; attempt++) {
+			const code = generate();
+			if (await this.findByCode(code)) continue;
+			return await this.create({
+				tenantId: input.tenantId,
+				referrerId: input.referrerId,
+				programId: input.programId,
+				code,
+				targetUrl: input.targetUrl ?? "",
+				label: input.label ?? "",
+				status: "active"
+			});
+		}
+		throw new Error(`ReferralLinkCollection.createWithUniqueCode: could not mint a unique code after 5 attempts \u2014 the code generator is returning colliding codes`);
+	}
+	/**
+	* Record a click on a share code: find the ACTIVE link, increment its
+	* {@link ReferralLink.clickCount}, and write an immutable ReferralTouch
+	* (kind `'click'`, evidence carrying the code/link/url plus any caller
+	* evidence). Returns `{ link, touch }` on success.
+	*
+	* Refusals return a typed result instead of throwing (clicks arrive from
+	* the edge — an unknown or disabled code is an expected outcome, not an
+	* exception): `refused: 'unknown_code'` (no such code; `link: null`) or
+	* `refused: 'link_disabled'` (link exists but is disabled; the link is
+	* returned, nothing is written).
+	*/
+	async recordClick(input) {
+		const link = await this.findByCode(input.code);
+		if (!link) return {
+			link: null,
+			touch: null,
+			refused: "unknown_code"
+		};
+		if (!link.isActive()) return {
+			link,
+			touch: null,
+			refused: "link_disabled"
+		};
+		const occurredAt = input.occurredAt ?? /* @__PURE__ */ new Date();
+		const touch = await (await ReferralTouchCollection.create({ db: this.db })).create({
+			tenantId: link.tenantId,
+			linkId: link.id ?? "",
+			code: link.code,
+			referrerId: link.referrerId,
+			programId: link.programId,
+			kind: "click",
+			subjectKind: input.subjectKind ?? "",
+			subjectId: input.subjectId ?? "",
+			occurredAt,
+			evidence: JSON.stringify({
+				...input.evidence ?? {},
+				code: link.code,
+				linkId: link.id ?? "",
+				targetUrl: link.targetUrl
+			})
+		});
+		await this.db.execute`UPDATE referral_links SET click_count = click_count + 1 WHERE id = ${link.id ?? ""}`;
+		return {
+			link: await this.get({ id: link.id }) ?? link,
+			touch
+		};
+	}
+};
+//#endregion
+//#region src/referrals/models/ReferralProgram.ts
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$2(target, key, result);
+	return result;
+};
+var ReferralProgram = class extends SmrtObject {
+	tenantId = null;
+	key = "";
+	/** Human-readable program name. */
+	name = "";
+	/**
+	* Program lifecycle: `draft` (default) → `active` → `paused` /
+	* `archived`. Applications gate intake on `active`; this module records
+	* the status without enforcing transition edges.
+	*/
+	status = "draft";
+	/**
+	* Default commissions-plan key suggested to new ReferralAgreements.
+	* Empty means the program has no default — agreements must name a plan.
+	*/
+	defaultCommissionPlanKey = "";
+	/**
+	* Default AttributionPolicy key `AttributionService.resolve()` uses when
+	* the caller passes no `policyKey` override.
+	*/
+	defaultAttributionPolicyKey = "";
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.key !== void 0) this.key = options.key;
+		if (options.name !== void 0) this.name = options.name;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.defaultCommissionPlanKey !== void 0) this.defaultCommissionPlanKey = options.defaultCommissionPlanKey;
+		if (options.defaultAttributionPolicyKey !== void 0) this.defaultAttributionPolicyKey = options.defaultAttributionPolicyKey;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Whether the program is accepting new referral activity. */
+	isActive() {
+		return this.status === "active";
+	}
+	/** Parse the metadata JSON string; returns `{}` on malformed content. */
+	getMetadata() {
+		try {
+			const parsed = JSON.parse(this.metadata);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+			return {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store the metadata object. */
+	setMetadata(metadata) {
+		this.metadata = JSON.stringify(metadata);
+	}
+};
+__decorateClass$2([tenantId({ nullable: true })], ReferralProgram.prototype, "tenantId", 2);
+__decorateClass$2([field({ required: true })], ReferralProgram.prototype, "key", 2);
+ReferralProgram = __decorateClass$2([TenantScoped({ mode: "optional" }), smrt({
+	conflictColumns: ["tenant_id", "key"],
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: true
+})], ReferralProgram);
+//#endregion
+//#region src/referrals/collections/ReferralProgramCollection.ts
+var ReferralProgramCollection = class extends SmrtCollection {
+	static _itemClass = ReferralProgram;
+	/**
+	* Look up a program by its natural key within the ambient tenant scope
+	* (`(tenant_id, key)` is the conflict key, so under a tenant context the
+	* auto-filter narrows this to at most one row).
+	*/
+	async findByKey(key) {
+		return (await this.list({
+			where: { key },
+			limit: 1
+		}))[0] ?? null;
+	}
+	/** Programs by status. */
+	async findByStatus(status) {
+		return await this.list({
+			where: { status },
+			orderBy: "created_at DESC"
+		});
+	}
+	/** All active programs. */
+	async findActive() {
+		return await this.findByStatus("active");
+	}
+};
+//#endregion
+//#region src/referrals/models/ReferralTermSnapshot.ts
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$1(target, key, result);
+	return result;
+};
+var persistedSnapshotState = /* @__PURE__ */ new WeakMap();
+var ReferralTermSnapshot = class extends SmrtObject {
+	tenantId = null;
+	referralId = "";
+	/** Id of the ReferralAgreement the terms came from. */
+	agreementId = "";
+	/** Version of the agreement at qualification time. */
+	agreementVersion = 0;
+	/** CommissionPlan key the components were copied from. */
+	planKey = "";
+	/**
+	* CommissionPlan version PINNED at qualification — when the agreement
+	* left the version unpinned (`0`), this records the latest-active version
+	* that was resolved.
+	*/
+	planVersion = 0;
+	/** AttributionPolicy key stamped on the referral at attribution. */
+	policyKey = "";
+	/** AttributionPolicy version stamped on the referral at attribution. */
+	policyVersion = 0;
+	/**
+	* FROZEN copy of the plan's components JSON — THE calculation inputs.
+	* Use {@link getComponents} for the typed array.
+	*/
+	components = "[]";
+	/** ISO 4217 currency the frozen terms are denominated in. */
+	currency = "USD";
+	/** Clearing window (days) copied from the agreement. */
+	clearingDays = 0;
+	/** Approval mode copied from the agreement. */
+	approvalMode = "manual";
+	/** Additional metadata as a JSON string (immutable like every field). */
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.referralId !== void 0) this.referralId = options.referralId;
+		if (options.agreementId !== void 0) this.agreementId = options.agreementId;
+		if (options.agreementVersion !== void 0) this.agreementVersion = options.agreementVersion;
+		if (options.planKey !== void 0) this.planKey = options.planKey;
+		if (options.planVersion !== void 0) this.planVersion = options.planVersion;
+		if (options.policyKey !== void 0) this.policyKey = options.policyKey;
+		if (options.policyVersion !== void 0) this.policyVersion = options.policyVersion;
+		if (options.components !== void 0) this.components = options.components;
+		if (options.currency !== void 0) this.currency = options.currency;
+		if (options.clearingDays !== void 0) this.clearingDays = options.clearingDays;
+		if (options.approvalMode !== void 0) this.approvalMode = options.approvalMode;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Capture the persisted state so the save guard can reject mutations. */
+	async initialize() {
+		await super.initialize();
+		if (await this.isSaved()) persistedSnapshotState.set(this, this.serializeState());
+		return this;
+	}
+	/**
+	* Parse {@link components} into the typed plan-component array the
+	* calculation service consumes; returns `[]` on empty/invalid JSON.
+	*/
+	getComponents() {
+		if (!this.components) return [];
+		try {
+			const parsed = JSON.parse(this.components);
+			return Array.isArray(parsed) ? parsed : [];
+		} catch {
+			return [];
+		}
+	}
+	/** Parse {@link metadata}; returns `{}` on malformed content. */
+	getMetadata() {
+		if (!this.metadata) return {};
+		try {
+			const parsed = JSON.parse(this.metadata);
+			return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		} catch {
+			return {};
+		}
+	}
+	/**
+	* Save with the full-immutability guard:
+	*
+	* - A hydrated persisted row must serialize IDENTICALLY to its captured
+	*   state — any field change throws (no-op re-saves pass).
+	* - An instance carrying an existing row's id WITHOUT having hydrated it
+	*   (e.g. `create({ id, _skipLoad: true })`) is rejected outright — blind
+	*   overwrites can't sidestep the comparison.
+	*/
+	async save() {
+		const captured = persistedSnapshotState.get(this);
+		if (captured !== void 0) {
+			if (captured !== this.serializeState()) throw new Error(`ReferralTermSnapshot ${this.id ?? "<new>"}: snapshots are immutable once created. Requalify the referral (ReferralQualificationService.requalify) to snapshot new terms instead of editing this row.`);
+		} else if (this.id && await this.isSaved()) throw new Error(`ReferralTermSnapshot ${this.id}: refusing to overwrite an existing snapshot row from a non-hydrated instance \u2014 snapshots are immutable once created.`);
+		const result = await super.save();
+		persistedSnapshotState.set(this, this.serializeState());
+		return result;
+	}
+	serializeState() {
+		return JSON.stringify({
+			tenantId: this.tenantId,
+			referralId: this.referralId,
+			agreementId: this.agreementId,
+			agreementVersion: this.agreementVersion,
+			planKey: this.planKey,
+			planVersion: this.planVersion,
+			policyKey: this.policyKey,
+			policyVersion: this.policyVersion,
+			components: this.components,
+			currency: this.currency,
+			clearingDays: this.clearingDays,
+			approvalMode: this.approvalMode,
+			metadata: this.metadata
+		});
+	}
+};
+__decorateClass$1([tenantId({ nullable: true })], ReferralTermSnapshot.prototype, "tenantId", 2);
+__decorateClass$1([foreignKey("Referral", { required: true })], ReferralTermSnapshot.prototype, "referralId", 2);
+ReferralTermSnapshot = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: ["list", "get"] },
+	mcp: { include: ["list", "get"] },
+	cli: false
+})], ReferralTermSnapshot);
+//#endregion
+//#region src/referrals/collections/ReferralTermSnapshotCollection.ts
+var ReferralTermSnapshotCollection = class extends SmrtCollection {
+	static _itemClass = ReferralTermSnapshot;
+	/**
+	* Every snapshot minted for one referral, newest first — index 0 is the
+	* currently governing snapshot only if the referral's `snapshotId` says
+	* so (requalification keeps old rows as history).
+	*/
+	async findByReferral(referralId) {
+		return await this.list({
+			where: { referralId },
+			orderBy: "created_at DESC"
+		});
+	}
+};
+//#endregion
+//#region src/referrals/models/Referrer.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+var Referrer = class extends SmrtObject {
+	tenantId = null;
+	profileId = "";
+	earnerId = "";
+	/** Human-readable display name for portals and operator views. */
+	displayName = "";
+	/**
+	* Role lifecycle: `pending` (default, awaiting approval) → `active` /
+	* `suspended`. Only active referrers should receive new links/agreements.
+	*/
+	status = "pending";
+	/**
+	* Free-form JSON object stored as a string. Use
+	* {@link getMetadata}/{@link setMetadata} instead of parsing manually.
+	*/
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.profileId !== void 0) this.profileId = options.profileId;
+		if (options.earnerId !== void 0) this.earnerId = options.earnerId;
+		if (options.displayName !== void 0) this.displayName = options.displayName;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	/** Whether the referrer may receive new links/agreements. */
+	isActive() {
+		return this.status === "active";
+	}
+	isPending() {
+		return this.status === "pending";
+	}
+	isSuspended() {
+		return this.status === "suspended";
+	}
+	/** Parse the metadata JSON string; returns `{}` on malformed content. */
+	getMetadata() {
+		try {
+			const parsed = JSON.parse(this.metadata);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+			return {};
+		} catch {
+			return {};
+		}
+	}
+	/** Serialize and store the metadata object. */
+	setMetadata(metadata) {
+		this.metadata = JSON.stringify(metadata);
+	}
+};
+__decorateClass([tenantId({ nullable: true })], Referrer.prototype, "tenantId", 2);
+__decorateClass([crossPackageRef("@happyvertical/smrt-profiles:Profile")], Referrer.prototype, "profileId", 2);
+__decorateClass([foreignKey("Earner")], Referrer.prototype, "earnerId", 2);
+Referrer = __decorateClass([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: [
+		"list",
+		"get",
+		"create"
+	] },
+	cli: true
+})], Referrer);
+//#endregion
+//#region src/referrals/collections/ReferrerCollection.ts
+var ReferrerCollection = class extends SmrtCollection {
+	static _itemClass = Referrer;
+	/**
+	* Find referrer roles held by a given profile (a profile may hold the
+	* role in several tenants/contexts).
+	*/
+	async findByProfile(profileId) {
+		return await this.list({
+			where: { profileId },
+			orderBy: "created_at DESC"
+		});
+	}
+	/** Referrers by status. */
+	async findByStatus(status) {
+		return await this.list({
+			where: { status },
+			orderBy: "created_at DESC"
+		});
+	}
+	/** All active referrers (eligible for new links/agreements). */
+	async findActive() {
+		return await this.findByStatus("active");
+	}
+};
+//#endregion
+//#region src/referrals/services/AttributionService.ts
+var MS_PER_DAY = 1440 * 60 * 1e3;
+var QualifiedReferralOverrideError = class extends Error {
+	constructor(referralIds) {
+		super(`AttributionService.override: target already has qualified referral(s) [${referralIds.join(", ")}] \u2014 qualified credit is governed by term snapshots and commission adjustments downstream, not re-attribution.`);
+		this.name = "QualifiedReferralOverrideError";
+	}
+};
+var AttributionService = class AttributionService {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	deps;
+	static async create(classOptions = {}) {
+		return new AttributionService({
+			touches: await ReferralTouchCollection.create(classOptions),
+			referrals: await ReferralCollection.create(classOptions),
+			exceptions: await AttributionExceptionCollection.create(classOptions),
+			policies: await AttributionPolicyCollection.create(classOptions),
+			programs: await ReferralProgramCollection.create(classOptions),
+			referrers: await ReferrerCollection.create(classOptions)
+		});
+	}
+	/**
+	* Resolve attribution for one target under one program.
+	*
+	* IDEMPOTENT: existing non-disqualified `attributed`/`qualified`
+	* referrals for the target+program are returned as-is (no new rows), and
+	* an already-OPEN exception for the target+program is returned instead of
+	* a duplicate.
+	*
+	* Flow:
+	* 1. **Policy** — the program's `defaultAttributionPolicyKey` (or the
+	*    `policyKey` override) is resolved via `latestActiveByKey`; no active
+	*    version → `refused: 'no_active_policy'`.
+	* 2. **Existing-client gate** — `isExistingClient` with a policy that
+	*    disallows it → `refused: 'existing_client_ineligible'`.
+	* 3. **Candidates** — touches gathered by the subject pair (when given)
+	*    and by the target pair, deduplicated, restricted to the program and
+	*    to `occurredAt` within `[now - windowDays, now]`.
+	* 4. **Eligibility** — self-referrals (candidate referrer's `profileId`
+	*    equals `subjectProfileId`) are dropped unless the policy allows
+	*    them. Nothing left → `refused: 'no_eligible_touches'`.
+	* 5. **Conflicts** — `conflictBehavior: 'review'` with more than one
+	*    distinct eligible referrer, exact-timestamp ties between distinct
+	*    referrers in `first_touch`/`last_touch`, or competing manual
+	*    assignments in `assigned` mode → an OPEN AttributionException
+	*    carrying the candidates; NO referral rows.
+	* 6. **Credit** — otherwise the mode elects the winner(s):
+	*    `first_touch`/`last_touch` (earliest/latest), `assigned` (most
+	*    recent manual assignment; assignments beat clicks by definition),
+	*    or `split` (every distinct eligible referrer, equal fractions
+	*    rounded to 4 dp with the remainder on the last, one shared
+	*    `splitGroupId`). Referrals are created `pending → attributed` with
+	*    the policy pin, winning touch, `attributedAt = now`, and
+	*    `expiresAt = now + windowDays`.
+	*/
+	async resolve(input) {
+		const now = input.now ?? /* @__PURE__ */ new Date();
+		const existing = (await this.deps.referrals.findByTarget(input.targetKind, input.targetId)).filter((referral) => referral.programId === input.programId && (referral.status === "attributed" || referral.status === "qualified"));
+		if (existing.length > 0) return {
+			referrals: existing,
+			exception: null
+		};
+		const openException = await this.deps.exceptions.findOpenByTarget(input.targetKind, input.targetId, input.programId);
+		if (openException) return {
+			referrals: [],
+			exception: openException
+		};
+		const program = await this.requireProgram(input.programId);
+		const policy = await this.resolvePolicy(program, input.policyKey, now);
+		if (!policy) return {
+			referrals: [],
+			exception: null,
+			refused: "no_active_policy"
+		};
+		if (input.isExistingClient && !policy.allowExistingClients) return {
+			referrals: [],
+			exception: null,
+			refused: "existing_client_ineligible"
+		};
+		const eligible = await this.gatherEligibleTouches(input, policy, now);
+		if (eligible.length === 0) return {
+			referrals: [],
+			exception: null,
+			refused: "no_eligible_touches"
+		};
+		const distinctReferrerIds = [...new Set(eligible.map((touch) => touch.referrerId))];
+		if (policy.conflictBehavior === "review" && distinctReferrerIds.length > 1) return {
+			referrals: [],
+			exception: await this.createOpenException({
+				input,
+				program,
+				policy,
+				conflictReason: "policy_review",
+				candidates: eligible
+			})
+		};
+		switch (policy.creditMode) {
+			case "first_touch":
+			case "last_touch": {
+				const winnerTime = policy.creditMode === "first_touch" ? eligible[0].occurredAt.getTime() : eligible[eligible.length - 1].occurredAt.getTime();
+				const atWinnerTime = eligible.filter((touch) => touch.occurredAt.getTime() === winnerTime);
+				if (new Set(atWinnerTime.map((touch) => touch.referrerId)).size > 1) return {
+					referrals: [],
+					exception: await this.createOpenException({
+						input,
+						program,
+						policy,
+						conflictReason: "tie",
+						candidates: eligible
+					})
+				};
+				const winner = policy.creditMode === "first_touch" ? atWinnerTime[0] : atWinnerTime[atWinnerTime.length - 1];
+				return {
+					referrals: [await this.createAttributedReferral({
+						tenantId: program.tenantId,
+						referrerId: winner.referrerId,
+						programId: input.programId,
+						targetKind: input.targetKind,
+						targetId: input.targetId,
+						policy,
+						creditFraction: 1,
+						splitGroupId: "",
+						primaryTouchId: winner.id ?? "",
+						now
+					})],
+					exception: null
+				};
+			}
+			case "assigned": {
+				const assignments = eligible.filter((touch) => touch.kind === "manual_assignment");
+				if (assignments.length === 0) return {
+					referrals: [],
+					exception: null,
+					refused: "no_eligible_touches"
+				};
+				if (new Set(assignments.map((touch) => touch.referrerId)).size > 1) return {
+					referrals: [],
+					exception: await this.createOpenException({
+						input,
+						program,
+						policy,
+						conflictReason: "competing_touches",
+						candidates: assignments
+					})
+				};
+				const winner = assignments[assignments.length - 1];
+				return {
+					referrals: [await this.createAttributedReferral({
+						tenantId: program.tenantId,
+						referrerId: winner.referrerId,
+						programId: input.programId,
+						targetKind: input.targetKind,
+						targetId: input.targetId,
+						policy,
+						creditFraction: 1,
+						splitGroupId: "",
+						primaryTouchId: winner.id ?? "",
+						now
+					})],
+					exception: null
+				};
+			}
+			case "split": {
+				const fractions = AttributionService.equalFractions(distinctReferrerIds.length);
+				const splitGroupId = distinctReferrerIds.length > 1 ? randomUUID() : "";
+				const referrals = [];
+				for (let i = 0; i < distinctReferrerIds.length; i++) {
+					const referrerId = distinctReferrerIds[i];
+					const primaryTouch = eligible.find((touch) => touch.referrerId === referrerId);
+					referrals.push(await this.createAttributedReferral({
+						tenantId: program.tenantId,
+						referrerId,
+						programId: input.programId,
+						targetKind: input.targetKind,
+						targetId: input.targetId,
+						policy,
+						creditFraction: fractions[i],
+						splitGroupId,
+						primaryTouchId: primaryTouch?.id ?? "",
+						now
+					}));
+				}
+				return {
+					referrals,
+					exception: null
+				};
+			}
+		}
+	}
+	/**
+	* Record an operator's manual assignment as an immutable
+	* `manual_assignment` ReferralTouch (evidence carries the actor, reason,
+	* and target) and return it. The caller then runs {@link resolve} — under
+	* an `assigned`-mode policy the assignment wins over click evidence.
+	*/
+	async recordManualAssignment(input) {
+		if (!input.actorProfileId) throw new Error("AttributionService.recordManualAssignment requires an actorProfileId");
+		const program = await this.requireProgram(input.programId);
+		const occurredAt = input.occurredAt ?? /* @__PURE__ */ new Date();
+		const useSubject = Boolean(input.subjectKind && input.subjectId);
+		return await this.deps.touches.create({
+			tenantId: program.tenantId,
+			referrerId: input.referrerId,
+			programId: input.programId,
+			kind: "manual_assignment",
+			subjectKind: useSubject ? input.subjectKind : input.targetKind,
+			subjectId: useSubject ? input.subjectId : input.targetId,
+			occurredAt,
+			evidence: JSON.stringify({
+				actorProfileId: input.actorProfileId,
+				reason: input.reason ?? "",
+				targetKind: input.targetKind,
+				targetId: input.targetId
+			})
+		});
+	}
+	/**
+	* Resolve an OPEN exception by awarding credit explicitly.
+	*
+	* Requires a non-empty `resolutionReason` (throws otherwise) and awards
+	* whose `creditFraction`s sum to 1.0 (±0.0001) across distinct referrers.
+	* Creates the attributed referral(s) from the exception's target/program
+	* (split semantics — shared `splitGroupId` — when several awards), then
+	* marks the exception resolved (`resolutionMode: 'override'`, the award
+	* audit fields, `resolvedReferralIds`).
+	*/
+	async resolveException(input) {
+		AttributionService.assertResolutionReason(input.resolutionReason, "resolveException");
+		AttributionService.assertActor(input.actorProfileId, "resolveException");
+		AttributionService.assertAwards(input.awards);
+		const now = input.now ?? /* @__PURE__ */ new Date();
+		const exception = await this.deps.exceptions.get({ id: input.exceptionId });
+		if (!exception) throw new Error(`AttributionService.resolveException: exception '${input.exceptionId}' not found`);
+		if (!exception.isOpen()) throw new Error(`AttributionService.resolveException: exception '${input.exceptionId}' is already resolved`);
+		const policyPin = await this.resolvePolicyPin(exception);
+		const candidates = exception.getCandidates();
+		const splitGroupId = input.awards.length > 1 ? randomUUID() : "";
+		const referrals = [];
+		for (const award of input.awards) {
+			const candidate = candidates.find((entry) => entry.referrerId === award.referrerId);
+			referrals.push(await this.createAttributedReferral({
+				tenantId: exception.tenantId,
+				referrerId: award.referrerId,
+				programId: exception.programId,
+				targetKind: exception.targetKind,
+				targetId: exception.targetId,
+				policy: null,
+				policyPin,
+				creditFraction: award.creditFraction,
+				splitGroupId,
+				primaryTouchId: candidate?.touchId ?? "",
+				now
+			}));
+		}
+		exception.markResolved({
+			mode: "override",
+			reason: input.resolutionReason,
+			resolvedByProfileId: input.actorProfileId,
+			referralIds: referrals.map((referral) => referral.id ?? ""),
+			at: now
+		});
+		await exception.save();
+		return {
+			referrals,
+			exception
+		};
+	}
+	/**
+	* Re-attribute an already-attributed target.
+	*
+	* Requires a non-empty `resolutionReason` and awards summing to 1.0.
+	* REFUSES (throws {@link QualifiedReferralOverrideError}) when the target
+	* has a QUALIFIED referral — those are governed by term snapshots and
+	* commission adjustments downstream. Otherwise: disqualifies the existing
+	* `attributed` referrals for the target+program (stamping the audit
+	* exception's id into their metadata), creates the newly awarded
+	* attributed referral(s), and writes a RESOLVED AttributionException as
+	* the audit record (candidates = the displaced + awarded referrers).
+	*
+	* The new referrals inherit the POLICY PIN the displaced credit carried
+	* (an override re-decides WHO earned the introduction, not which policy
+	* version governed it); the program's current default active policy is
+	* the fallback when nothing was displaced.
+	*/
+	async override(input) {
+		AttributionService.assertResolutionReason(input.resolutionReason, "override");
+		AttributionService.assertActor(input.actorProfileId, "override");
+		AttributionService.assertAwards(input.awards);
+		const now = input.now ?? /* @__PURE__ */ new Date();
+		const forTarget = (await this.deps.referrals.findByTarget(input.targetKind, input.targetId)).filter((referral) => referral.programId === input.programId);
+		const qualified = forTarget.filter((referral) => referral.status === "qualified");
+		if (qualified.length > 0) throw new QualifiedReferralOverrideError(qualified.map((referral) => referral.id ?? ""));
+		const displaced = forTarget.filter((referral) => referral.status === "attributed");
+		const program = await this.requireProgram(input.programId);
+		const policyPin = await this.resolveOverridePolicyPin(program, displaced);
+		const candidates = [];
+		for (const referral of displaced) {
+			const touch = referral.primaryTouchId ? await this.deps.touches.get({ id: referral.primaryTouchId }) : null;
+			candidates.push({
+				touchId: referral.primaryTouchId,
+				referrerId: referral.referrerId,
+				kind: touch?.kind ?? "manual_assignment",
+				occurredAt: (touch?.occurredAt ?? referral.attributedAt ?? now).toISOString()
+			});
+		}
+		for (const award of input.awards) candidates.push({
+			touchId: "",
+			referrerId: award.referrerId,
+			kind: "manual_assignment",
+			occurredAt: now.toISOString()
+		});
+		const exception = await this.deps.exceptions.create({
+			tenantId: program.tenantId,
+			targetKind: input.targetKind,
+			targetId: input.targetId,
+			programId: input.programId,
+			status: "open",
+			conflictReason: "override",
+			candidates: JSON.stringify(candidates),
+			metadata: JSON.stringify(policyPin)
+		});
+		for (const referral of displaced) {
+			referral.setMetadata({
+				...referral.getMetadata(),
+				overriddenByExceptionId: exception.id ?? "",
+				overriddenAt: now.toISOString()
+			});
+			referral.disqualify();
+			await referral.save();
+		}
+		const splitGroupId = input.awards.length > 1 ? randomUUID() : "";
+		const referrals = [];
+		for (const award of input.awards) referrals.push(await this.createAttributedReferral({
+			tenantId: program.tenantId,
+			referrerId: award.referrerId,
+			programId: input.programId,
+			targetKind: input.targetKind,
+			targetId: input.targetId,
+			policy: null,
+			policyPin,
+			creditFraction: award.creditFraction,
+			splitGroupId,
+			primaryTouchId: "",
+			now
+		}));
+		exception.markResolved({
+			mode: "override",
+			reason: input.resolutionReason,
+			resolvedByProfileId: input.actorProfileId,
+			referralIds: referrals.map((referral) => referral.id ?? ""),
+			at: now
+		});
+		await exception.save();
+		return {
+			referrals,
+			exception
+		};
+	}
+	async requireProgram(programId) {
+		const program = await this.deps.programs.get({ id: programId });
+		if (!program) throw new Error(`AttributionService: program '${programId}' not found`);
+		return program;
+	}
+	/**
+	* The active policy governing a resolution: the explicit `policyKey`
+	* override when given, else the program's default key; resolved to its
+	* latest ACTIVE version. `null` when no key or no active version.
+	*/
+	async resolvePolicy(program, policyKeyOverride, at = /* @__PURE__ */ new Date()) {
+		const policyKey = policyKeyOverride ?? program.defaultAttributionPolicyKey;
+		if (!policyKey) return null;
+		return await this.deps.policies.latestActiveByKey(policyKey, at, program.tenantId);
+	}
+	/**
+	* Candidate touches for a resolution: gathered by the subject pair (when
+	* given) and by the target pair, deduplicated, restricted to the program,
+	* to `occurredAt` within `[now - windowDays, now]`, and to referrers that
+	* pass the self-referral gate. Sorted by `occurredAt` ascending.
+	*/
+	async gatherEligibleTouches(input, policy, now) {
+		const byId = /* @__PURE__ */ new Map();
+		if (input.subjectKind && input.subjectId) for (const touch of await this.deps.touches.findBySubject(input.subjectKind, input.subjectId)) byId.set(touch.id ?? "", touch);
+		for (const touch of await this.deps.touches.findBySubject(input.targetKind, input.targetId)) byId.set(touch.id ?? "", touch);
+		const windowStart = now.getTime() - policy.windowDays * MS_PER_DAY;
+		const inWindow = [...byId.values()].filter((touch) => {
+			if (touch.programId !== input.programId) return false;
+			const at = touch.occurredAt.getTime();
+			return at >= windowStart && at <= now.getTime();
+		});
+		let eligible = inWindow;
+		if (!policy.allowSelfReferral && input.subjectProfileId) {
+			const referrerProfiles = /* @__PURE__ */ new Map();
+			for (const touch of inWindow) {
+				if (referrerProfiles.has(touch.referrerId)) continue;
+				const referrer = await this.deps.referrers.get({ id: touch.referrerId });
+				referrerProfiles.set(touch.referrerId, referrer?.profileId ?? "");
+			}
+			eligible = inWindow.filter((touch) => referrerProfiles.get(touch.referrerId) !== input.subjectProfileId);
+		}
+		return eligible.sort((a, b) => a.occurredAt.getTime() - b.occurredAt.getTime());
+	}
+	/** Create an OPEN exception carrying the competing candidates. */
+	async createOpenException(params) {
+		const { input, program, policy } = params;
+		return await this.deps.exceptions.create({
+			tenantId: program.tenantId,
+			targetKind: input.targetKind,
+			targetId: input.targetId,
+			programId: input.programId,
+			status: "open",
+			conflictReason: params.conflictReason,
+			candidates: JSON.stringify(params.candidates.map((touch) => ({
+				touchId: touch.id ?? "",
+				referrerId: touch.referrerId,
+				kind: touch.kind,
+				occurredAt: touch.occurredAt.toISOString()
+			}))),
+			metadata: JSON.stringify({
+				policyKey: policy.policyKey,
+				policyVersion: policy.version,
+				windowDays: policy.windowDays
+			})
+		});
+	}
+	/**
+	* The policy pin an exception was raised under (stamped into its
+	* metadata at creation); falls back to the program's current default
+	* active policy for exceptions created without one.
+	*/
+	async resolvePolicyPin(exception) {
+		const meta = exception.getMetadata();
+		if (typeof meta.policyKey === "string" && meta.policyKey) return {
+			policyKey: meta.policyKey,
+			policyVersion: typeof meta.policyVersion === "number" ? meta.policyVersion : 0,
+			windowDays: typeof meta.windowDays === "number" ? meta.windowDays : null
+		};
+		if (exception.programId) {
+			const program = await this.deps.programs.get({ id: exception.programId });
+			if (program) {
+				const policy = await this.resolvePolicy(program, void 0);
+				if (policy) return {
+					policyKey: policy.policyKey,
+					policyVersion: policy.version,
+					windowDays: policy.windowDays
+				};
+			}
+		}
+		return {
+			policyKey: "",
+			policyVersion: 0,
+			windowDays: null
+		};
+	}
+	/**
+	* The policy pin an override re-attributes under: the pin the displaced
+	* credit carried (looking the exact version's `windowDays` back up for
+	* the new expiry), falling back to the program's current default active
+	* policy when nothing pinned was displaced.
+	*/
+	async resolveOverridePolicyPin(program, displaced) {
+		const pinned = displaced.find((referral) => referral.policyKey);
+		if (pinned) {
+			const versions = await this.deps.policies.list({ where: {
+				policyKey: pinned.policyKey,
+				version: pinned.policyVersion
+			} });
+			const laneVersion = versions.find((policy2) => policy2.tenantId === program.tenantId) ?? versions.find((policy2) => policy2.tenantId === null) ?? null;
+			return {
+				policyKey: pinned.policyKey,
+				policyVersion: pinned.policyVersion,
+				windowDays: laneVersion?.windowDays ?? null
+			};
+		}
+		const policy = await this.resolvePolicy(program, void 0);
+		return policy ? {
+			policyKey: policy.policyKey,
+			policyVersion: policy.version,
+			windowDays: policy.windowDays
+		} : {
+			policyKey: "",
+			policyVersion: 0,
+			windowDays: null
+		};
+	}
+	/**
+	* Create one referral as `pending`, transition it `pending → attributed`
+	* (stamping `attributedAt`), set the policy pin and expiry, and save.
+	*/
+	async createAttributedReferral(params) {
+		const pin = params.policy ? {
+			policyKey: params.policy.policyKey,
+			policyVersion: params.policy.version,
+			windowDays: params.policy.windowDays
+		} : params.policyPin ?? {
+			policyKey: "",
+			policyVersion: 0,
+			windowDays: null
+		};
+		const referral = await this.deps.referrals.create({
+			tenantId: params.tenantId,
+			referrerId: params.referrerId,
+			programId: params.programId,
+			targetKind: params.targetKind,
+			targetId: params.targetId,
+			policyKey: pin.policyKey,
+			policyVersion: pin.policyVersion,
+			creditFraction: params.creditFraction,
+			splitGroupId: params.splitGroupId,
+			primaryTouchId: params.primaryTouchId,
+			status: "pending"
+		});
+		referral.markAttributed(params.now);
+		referral.expiresAt = pin.windowDays !== null ? new Date(params.now.getTime() + pin.windowDays * MS_PER_DAY) : null;
+		await referral.save();
+		return referral;
+	}
+	/**
+	* Equal split fractions for `n` referrers, each rounded to 4 decimal
+	* places, with the LAST adjusted so the set sums to exactly 1.0.
+	*/
+	static equalFractions(n) {
+		if (n <= 1) return [1];
+		const base = Math.floor(1e4 / n) / 1e4;
+		const fractions = new Array(n).fill(base);
+		fractions[n - 1] = Math.round((1 - base * (n - 1)) * 1e4) / 1e4;
+		return fractions;
+	}
+	static assertResolutionReason(reason, method) {
+		if (!reason?.trim()) throw new Error(`AttributionService.${method} requires a non-empty resolutionReason`);
+	}
+	/**
+	* Attribution decisions are audited — a blank actor would permanently
+	* resolve/override credit with an empty `resolvedByProfileId`, defeating
+	* the audit trail.
+	*/
+	static assertActor(actorProfileId, method) {
+		if (!actorProfileId?.trim()) throw new Error(`AttributionService.${method} requires a non-empty actorProfileId`);
+	}
+	static assertAwards(awards) {
+		if (!awards || awards.length === 0) throw new Error("AttributionService: at least one award is required");
+		const seen = /* @__PURE__ */ new Set();
+		let sum = 0;
+		for (const award of awards) {
+			if (!award.referrerId) throw new Error("AttributionService: award.referrerId is required");
+			if (seen.has(award.referrerId)) throw new Error(`AttributionService: duplicate award for referrer '${award.referrerId}'`);
+			seen.add(award.referrerId);
+			if (!Number.isFinite(award.creditFraction) || award.creditFraction <= 0 || award.creditFraction > 1) throw new Error(`AttributionService: award.creditFraction must be in (0, 1] \u2014 got ${award.creditFraction}`);
+			sum += award.creditFraction;
+		}
+		if (Math.abs(sum - 1) > 1e-4) throw new Error(`AttributionService: award creditFractions must sum to 1.0 (\xB10.0001) \u2014 got ${sum}`);
+	}
+};
+//#endregion
+//#region src/referrals/services/ReferralCommissionService.ts
+var REFERRAL_TERMS_SNAPSHOT_KIND = "referral_term_snapshot";
+var ReferralCommissionService = class ReferralCommissionService {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	deps;
+	static async create(classOptions = {}) {
+		return new ReferralCommissionService({
+			referrals: await ReferralCollection.create(classOptions),
+			snapshots: await ReferralTermSnapshotCollection.create(classOptions),
+			referrers: await ReferrerCollection.create(classOptions),
+			calculation: await CommissionCalculationService.create(classOptions),
+			commissions: await CommissionCollection.create(classOptions)
+		});
+	}
+	/**
+	* Turn one earning event into Commissions for every qualified referral it
+	* concerns.
+	*
+	* Referral resolution: explicit `referralIds` when given (rows that are
+	* missing / not qualified are reported in `skippedReferrals`), else
+	* `findQualifiedByTarget(targetKind, targetId)`. One of the two forms is
+	* required.
+	*
+	* Per referral:
+	* 1. Load its ReferralTermSnapshot (`'missing_snapshot'` skip when the
+	*    pointer is empty/dangling).
+	* 2. Resolve the referrer's `earnerId`
+	*    (`'referrer_missing_earner'` skip when absent — roles without a
+	*    payout account cannot earn).
+	* 3. Delegate to `CommissionCalculationService.calculateForEvent` with
+	*    the snapshot's plan pin, FROZEN components, currency (mismatches
+	*    surface as the calc service's `currency_mismatch` skips),
+	*    clearingDays, the referral's `creditFraction` as the share, its
+	*    `splitGroupId`, the
+	*    `('referral_term_snapshot', snapshot.id)` terms reference, and an
+	*    occurrence resolver counting existing Commissions for
+	*    `(termsSnapshotId, componentKey)` from PRIOR events.
+	*
+	* Fully idempotent on replay: the calculation service's dedupe keys
+	* return prior rows in each outcome's `existing`.
+	*/
+	async processEarningEvent(input) {
+		const { event } = input;
+		if (!event?.id) throw new Error("ReferralCommissionService.processEarningEvent requires a persisted event (missing id)");
+		const skippedReferrals = [];
+		const referrals = [];
+		if (input.referralIds && input.referralIds.length > 0) for (const referralId of input.referralIds) {
+			const referral = await this.deps.referrals.get({ id: referralId });
+			if (!referral) {
+				skippedReferrals.push({
+					referralId,
+					reason: "referral_not_found"
+				});
+				continue;
+			}
+			if (referral.status !== "qualified") {
+				skippedReferrals.push({
+					referralId,
+					reason: "not_qualified"
+				});
+				continue;
+			}
+			referrals.push(referral);
+		}
+		else if (input.targetKind && input.targetId) referrals.push(...await this.deps.referrals.findQualifiedByTarget(input.targetKind, input.targetId));
+		else throw new Error("ReferralCommissionService.processEarningEvent requires referralIds or a (targetKind, targetId) pair");
+		const results = [];
+		for (const referral of referrals) {
+			const referralId = referral.id ?? "";
+			const snapshot = referral.snapshotId ? await this.deps.snapshots.get({ id: referral.snapshotId }) : null;
+			if (!snapshot?.id) {
+				skippedReferrals.push({
+					referralId,
+					reason: "missing_snapshot"
+				});
+				continue;
+			}
+			const lane = referral.tenantId ?? null;
+			if (event.tenantId !== null && event.tenantId !== lane || (snapshot.tenantId ?? null) !== lane) {
+				skippedReferrals.push({
+					referralId,
+					reason: "tenant_mismatch"
+				});
+				continue;
+			}
+			const referrer = await this.deps.referrers.get({ id: referral.referrerId });
+			if (referrer && referrer.tenantId !== null && referrer.tenantId !== lane) {
+				skippedReferrals.push({
+					referralId,
+					reason: "tenant_mismatch"
+				});
+				continue;
+			}
+			if (!referrer?.earnerId) {
+				skippedReferrals.push({
+					referralId,
+					reason: "referrer_missing_earner"
+				});
+				continue;
+			}
+			const snapshotId = snapshot.id;
+			const calculation = await this.deps.calculation.calculateForEvent({
+				event,
+				planKey: snapshot.planKey,
+				planVersion: snapshot.planVersion,
+				components: snapshot.getComponents(),
+				earnerId: referrer.earnerId,
+				shareFraction: referral.creditFraction,
+				splitGroupId: referral.splitGroupId,
+				termsSnapshotKind: REFERRAL_TERMS_SNAPSHOT_KIND,
+				termsSnapshotId: snapshotId,
+				currency: snapshot.currency,
+				clearingDays: snapshot.clearingDays,
+				anchorAt: referral.qualifiedAt ?? void 0,
+				occurrenceCountResolver: async (componentKey) => {
+					return (await this.deps.commissions.list({ where: {
+						termsSnapshotId: snapshotId,
+						componentKey
+					} })).filter((commission) => commission.earningEventId !== event.id).length;
+				}
+			});
+			results.push({
+				referralId,
+				created: calculation.created,
+				existing: calculation.existing,
+				skipped: calculation.skipped
+			});
+		}
+		return {
+			results,
+			skippedReferrals
+		};
+	}
+};
+//#endregion
+//#region src/referrals/services/ReferralQualificationService.ts
+var ReferralQualificationService = class ReferralQualificationService {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	deps;
+	static async create(classOptions = {}) {
+		return new ReferralQualificationService({
+			referrals: await ReferralCollection.create(classOptions),
+			agreements: await ReferralAgreementCollection.create(classOptions),
+			plans: await CommissionPlanCollection.create(classOptions),
+			policies: await AttributionPolicyCollection.create(classOptions),
+			snapshots: await ReferralTermSnapshotCollection.create(classOptions),
+			referrers: await ReferrerCollection.create(classOptions)
+		});
+	}
+	/**
+	* Qualify an attributed referral.
+	*
+	* Flow:
+	* 1. **Status** — the referral must be `attributed`
+	*    (`reason: 'not_attributed'` otherwise). Already `qualified` →
+	*    IDEMPOTENT: the existing snapshot returns with `created: false`.
+	* 2. **Eligibility re-check** — the attribution-time policy version's
+	*    flags are re-applied against the caller's current knowledge:
+	*    `isExistingClient` (`existing_client_ineligible`) and
+	*    `subjectProfileId` vs the referrer's profile
+	*    (`self_referral_ineligible`). Refusals do NOT change the referral's
+	*    status — disqualification stays an explicit caller decision.
+	* 3. **Agreement** — the ACTIVE ReferralAgreement for
+	*    (referrerId, programId) effective at `now`
+	*    (`reason: 'no_active_agreement'` when none).
+	* 4. **Plan** — the agreement's pinned `commissionPlanVersion`, or the
+	*    latest active version when the pin is `0`; the resolved version must
+	*    be ACTIVE (`reason: 'no_active_plan'` otherwise).
+	* 5. **Snapshot** — mint the immutable ReferralTermSnapshot (frozen
+	*    component copy, currency, clearingDays, approvalMode, agreement +
+	*    plan + policy version refs), point `referral.snapshotId` at it, and
+	*    transition `attributed → qualified` (stamping `qualifiedAt`).
+	*/
+	async qualify(input) {
+		const now = input.now ?? /* @__PURE__ */ new Date();
+		const referral = await this.requireReferral(input.referralId, "qualify");
+		if (referral.status === "qualified") return {
+			qualified: true,
+			created: false,
+			snapshot: referral.snapshotId ? await this.deps.snapshots.get({ id: referral.snapshotId }) : null,
+			referral
+		};
+		if (referral.status !== "attributed") return {
+			qualified: false,
+			created: false,
+			snapshot: null,
+			referral,
+			reason: "not_attributed"
+		};
+		const policy = await this.findPolicyVersion(referral.policyKey, referral.policyVersion, referral.tenantId);
+		if (policy) {
+			if (input.isExistingClient && !policy.allowExistingClients) return {
+				qualified: false,
+				created: false,
+				snapshot: null,
+				referral,
+				reason: "existing_client_ineligible"
+			};
+			if (input.subjectProfileId && !policy.allowSelfReferral) {
+				const referrer = await this.deps.referrers.get({ id: referral.referrerId });
+				if (referrer && referrer.profileId === input.subjectProfileId) return {
+					qualified: false,
+					created: false,
+					snapshot: null,
+					referral,
+					reason: "self_referral_ineligible"
+				};
+			}
+		}
+		const agreement = await this.deps.agreements.activeFor(referral.referrerId, referral.programId, now);
+		if (!agreement) return {
+			qualified: false,
+			created: false,
+			snapshot: null,
+			referral,
+			reason: "no_active_agreement"
+		};
+		const plan = await this.resolvePlan(agreement, now);
+		if (!plan) return {
+			qualified: false,
+			created: false,
+			snapshot: null,
+			referral,
+			reason: "no_active_plan"
+		};
+		const snapshot = await this.mintSnapshot(referral, agreement, plan);
+		referral.snapshotId = snapshot.id ?? "";
+		referral.markQualified(now);
+		await referral.save();
+		return {
+			qualified: true,
+			created: true,
+			snapshot,
+			referral
+		};
+	}
+	/**
+	* Explicitly re-snapshot a QUALIFIED referral under the CURRENT terms —
+	* the "amendment explicitly applied" path: after a plan/agreement
+	* amendment, earnings keep flowing through the OLD snapshot until an
+	* operator invokes this.
+	*
+	* Creates a NEW snapshot from the currently active agreement/plan,
+	* repoints `referral.snapshotId`, leaves the old snapshot row untouched
+	* (history — commissions it produced still reference it), and appends
+	* `{ at, reason, fromSnapshotId, toSnapshotId }` to the referral
+	* metadata's `requalifications` array.
+	*
+	* Throws on misuse (unknown referral, non-qualified status, empty
+	* reason); refuses with a typed reason when no active agreement/plan
+	* currently governs.
+	*/
+	async requalify(input) {
+		if (!input.reason?.trim()) throw new Error("ReferralQualificationService.requalify requires a non-empty reason");
+		const now = input.now ?? /* @__PURE__ */ new Date();
+		const referral = await this.requireReferral(input.referralId, "requalify");
+		if (referral.status !== "qualified") throw new Error(`ReferralQualificationService.requalify: referral '${input.referralId}' is '${referral.status}' \u2014 only qualified referrals can be re-snapshotted`);
+		const agreement = await this.deps.agreements.activeFor(referral.referrerId, referral.programId, now);
+		if (!agreement) return {
+			requalified: false,
+			snapshot: null,
+			previousSnapshotId: referral.snapshotId,
+			reason: "no_active_agreement"
+		};
+		const plan = await this.resolvePlan(agreement, now);
+		if (!plan) return {
+			requalified: false,
+			snapshot: null,
+			previousSnapshotId: referral.snapshotId,
+			reason: "no_active_plan"
+		};
+		const previousSnapshotId = referral.snapshotId;
+		const snapshot = await this.mintSnapshot(referral, agreement, plan);
+		const meta = referral.getMetadata();
+		const history = Array.isArray(meta.requalifications) ? meta.requalifications : [];
+		history.push({
+			at: now.toISOString(),
+			reason: input.reason,
+			fromSnapshotId: previousSnapshotId,
+			toSnapshotId: snapshot.id ?? ""
+		});
+		referral.setMetadata({
+			...meta,
+			requalifications: history
+		});
+		referral.snapshotId = snapshot.id ?? "";
+		await referral.save();
+		return {
+			requalified: true,
+			snapshot,
+			previousSnapshotId
+		};
+	}
+	async requireReferral(referralId, method) {
+		const referral = await this.deps.referrals.get({ id: referralId });
+		if (!referral) throw new Error(`ReferralQualificationService.${method}: referral '${referralId}' not found`);
+		return referral;
+	}
+	/**
+	* The exact policy version pinned on the referral, when it exists —
+	* resolved in the REFERRAL's tenant lane (global fallback): background
+	* qualification runs without ambient tenant context, and another
+	* tenant's same-keyed policy must never supply the eligibility flags.
+	*/
+	async findPolicyVersion(policyKey, version, tenantId = null) {
+		if (!policyKey || version <= 0) return null;
+		const results = await this.deps.policies.list({ where: {
+			policyKey,
+			version
+		} });
+		return results.find((policy) => policy.tenantId === tenantId) ?? results.find((policy) => policy.tenantId === null) ?? null;
+	}
+	/**
+	* The CommissionPlan an agreement binds: the pinned version when
+	* `commissionPlanVersion > 0`, else the latest active version. Either
+	* way the resolved row must be ACTIVE — superseded/retired terms cannot
+	* govern a NEW qualification (an amendment should be activated, or the
+	* agreement re-pinned, first).
+	*/
+	async resolvePlan(agreement, at = /* @__PURE__ */ new Date()) {
+		if (!agreement.commissionPlanKey) return null;
+		if (agreement.commissionPlanVersion > 0) {
+			const results = await this.deps.plans.list({ where: {
+				planKey: agreement.commissionPlanKey,
+				version: agreement.commissionPlanVersion,
+				status: "active"
+			} });
+			return results.find((plan) => plan.tenantId === agreement.tenantId) ?? results.find((plan) => plan.tenantId === null) ?? null;
+		}
+		return await this.deps.plans.latestActiveByKey(agreement.commissionPlanKey, at, agreement.tenantId);
+	}
+	/**
+	* Mint the immutable snapshot: agreement/plan/policy refs plus the FROZEN
+	* component copy and the calculation inputs. `planVersion` records the
+	* RESOLVED version — this is where an unpinned (`0`) agreement version
+	* gets pinned.
+	*/
+	async mintSnapshot(referral, agreement, plan) {
+		return await this.deps.snapshots.create({
+			tenantId: referral.tenantId,
+			referralId: referral.id ?? "",
+			agreementId: agreement.id ?? "",
+			agreementVersion: agreement.version,
+			planKey: plan.planKey,
+			planVersion: plan.version,
+			policyKey: referral.policyKey,
+			policyVersion: referral.policyVersion,
+			components: plan.components,
+			currency: plan.currency,
+			clearingDays: agreement.clearingDays,
+			approvalMode: agreement.approvalMode
+		});
+	}
+};
+//#endregion
+export { ATTRIBUTION_EXCEPTION_STATUSES as A, AttributionExceptionCollection as B, ReferralAgreementCollection as C, validateAttributionPolicyTerms as D, AttributionPolicy as E, REFERRAL_LINK_STATUSES as F, REFERRAL_PROGRAM_STATUSES as I, REFERRAL_STATUSES as L, ATTRIBUTION_RESOLUTION_MODES as M, REFERRAL_AGREEMENT_APPROVAL_MODES as N, ATTRIBUTION_CONFLICT_BEHAVIORS as O, REFERRAL_AGREEMENT_STATUSES as P, REFERRAL_TOUCH_KINDS as R, Referral as S, AttributionPolicyCollection as T, AttributionException as V, ReferralTouchCollection as _, QualifiedReferralOverrideError as a, assertHttpTargetUrl as b, ReferralTermSnapshotCollection as c, ReferralProgram as d, MAX_CODE_GENERATION_ATTEMPTS as f, generateReferralCode as g, ReferralLinkCollection as h, AttributionService as i, ATTRIBUTION_POLICY_STATUSES as j, ATTRIBUTION_CREDIT_MODES as k, ReferralTermSnapshot as l, REFERRAL_CODE_LENGTH as m, REFERRAL_TERMS_SNAPSHOT_KIND as n, ReferrerCollection as o, REFERRAL_CODE_ALPHABET as p, ReferralCommissionService as r, Referrer as s, ReferralQualificationService as t, ReferralProgramCollection as u, ReferralTouch as v, ReferralAgreement as w, ReferralCollection as x, ReferralLink as y, REFERRER_STATUSES as z };
+
+//# sourceMappingURL=referrals-BY47p70T.js.map