@classytic/crm 0.1.1 → 0.3.0

package/dist/index.js

@@ -1,7 +1,1278 @@
+import { t as __exportAll } from "./chunk.js";
+import { Schema } from "mongoose";
+import { Repository, aggregateHelpersPlugin, methodRegistryPlugin, multiTenantPlugin } from "@classytic/mongokit";
+import { createEvent as createEvent$1, matchEventPattern } from "@classytic/primitives/events";
+import { assertAndClaim, defineStateMachine } from "@classytic/primitives/state-machine";
 import { randomUUID } from "node:crypto";
-import { createEvent, matchEventPattern } from "@classytic/primitives/events";
 import { z } from "zod";
-//#region src/domain/errors.ts
+import { appendStatus, lastTransitionTo, latestEntry, timeInStatus } from "@classytic/primitives/status-history";
+//#region src/models/tenant-field.ts
+/**
+* Per PACKAGE_RULES §9.2: never hardcode the tenant column's Mongoose
+* type — let the engine config drive both the schema and the
+* multiTenantPlugin so they stay in sync. Hosts with Better Auth pick
+* `'objectId'` (default for new packages — enables `$lookup`,
+* `.populate()`, QueryParser `?lookup=organizationId`); hosts with
+* UUID/slug auth pick `'string'`.
+*/
+/**
+* Tenant-column schema definition. Use this anywhere a model has
+* `organizationId` — never write the raw type in a schema file.
+*/
+function tenantFieldDef(config) {
+	return config.tenantFieldType === "objectId" ? {
+		type: Schema.Types.ObjectId,
+		required: true,
+		ref: "organization",
+		index: true
+	} : {
+		type: String,
+		required: true,
+		index: true
+	};
+}
+//#endregion
+//#region src/models/pipeline.schema.ts
+/**
+* Pipeline + embedded Stages.
+*
+* Sales motions are the cardinality consumers think in — "new business
+* vs. expansion vs. partnerships." Each Pipeline owns its Stages
+* inline (embedded subdocs) because stages have no meaning outside a
+* pipeline and the read pattern is "load the pipeline + all its
+* stages" 99% of the time. Opportunities reference a `(pipelineId,
+* stageId)` pair to pin themselves.
+*/
+const stageSubSchema = new Schema({
+	name: {
+		type: String,
+		required: true,
+		trim: true,
+		maxlength: 100
+	},
+	sequence: {
+		type: Number,
+		required: true,
+		min: 1
+	},
+	defaultProbability: {
+		type: Number,
+		required: true,
+		min: 0,
+		max: 1
+	},
+	color: {
+		type: String,
+		trim: true,
+		maxlength: 32
+	},
+	description: {
+		type: String,
+		trim: true,
+		maxlength: 500
+	}
+}, { _id: true });
+function buildPipelineSchema(config) {
+	const schema = new Schema({
+		organizationId: tenantFieldDef(config),
+		name: {
+			type: String,
+			required: true,
+			trim: true,
+			maxlength: 200
+		},
+		isArchived: {
+			type: Boolean,
+			default: false,
+			index: true
+		},
+		stages: {
+			type: [stageSubSchema],
+			default: []
+		},
+		teamRef: {
+			type: String,
+			trim: true,
+			maxlength: 100
+		},
+		metadata: { type: Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		organizationId: 1,
+		isArchived: 1
+	});
+	schema.index({
+		organizationId: 1,
+		name: 1
+	});
+	return schema;
+}
+function createPipelineModel(connection, config) {
+	if (connection.models.Pipeline) connection.deleteModel("Pipeline");
+	return connection.model("Pipeline", buildPipelineSchema(config));
+}
+//#endregion
+//#region src/enums/lead-status.ts
+/**
+* Lead lifecycle — from initial inquiry through conversion.
+*
+*   new          — just captured (web form, import, referral)
+*   contacted    — SDR has reached out
+*   qualified    — meets ICP / BANT
+*   converted    — turned into Contact + Account + Opportunity
+*   disqualified — rejected (bad fit, spam, duplicate)
+*   nurturing    — not ready now; parked for later outreach
+*/
+const LEAD_STATUSES = [
+	"new",
+	"contacted",
+	"qualified",
+	"converted",
+	"disqualified",
+	"nurturing"
+];
+const LEAD_TRANSITIONS = {
+	new: [
+		"contacted",
+		"qualified",
+		"disqualified",
+		"nurturing"
+	],
+	contacted: [
+		"qualified",
+		"disqualified",
+		"nurturing"
+	],
+	qualified: [
+		"converted",
+		"disqualified",
+		"nurturing"
+	],
+	nurturing: [
+		"contacted",
+		"qualified",
+		"disqualified"
+	],
+	converted: [],
+	disqualified: []
+};
+function canTransitionLead(from, to) {
+	return LEAD_TRANSITIONS[from].includes(to);
+}
+//#endregion
+//#region src/models/lead.schema.ts
+/**
+* Lead — top-of-funnel inquiry, pre-qualification.
+*/
+const statusEntrySchema$3 = new Schema({
+	status: {
+		type: String,
+		enum: LEAD_STATUSES,
+		required: true
+	},
+	occurredAt: {
+		type: Date,
+		required: true
+	},
+	by: { type: String },
+	note: { type: String }
+}, { _id: false });
+function buildLeadSchema(config) {
+	const schema = new Schema({
+		organizationId: tenantFieldDef(config),
+		fullName: {
+			type: String,
+			required: true,
+			trim: true,
+			maxlength: 200
+		},
+		firstName: {
+			type: String,
+			trim: true,
+			maxlength: 100
+		},
+		lastName: {
+			type: String,
+			trim: true,
+			maxlength: 100
+		},
+		email: {
+			type: String,
+			trim: true,
+			lowercase: true,
+			maxlength: 255
+		},
+		phone: {
+			type: String,
+			trim: true,
+			maxlength: 50
+		},
+		companyName: {
+			type: String,
+			trim: true,
+			maxlength: 200
+		},
+		jobTitle: {
+			type: String,
+			trim: true,
+			maxlength: 150
+		},
+		source: {
+			type: String,
+			trim: true,
+			maxlength: 100
+		},
+		campaignRef: {
+			type: String,
+			trim: true,
+			maxlength: 100
+		},
+		score: {
+			type: Number,
+			default: 0
+		},
+		status: {
+			type: String,
+			enum: LEAD_STATUSES,
+			default: "new",
+			index: true
+		},
+		statusHistory: {
+			type: [statusEntrySchema$3],
+			default: []
+		},
+		ownerId: {
+			type: String,
+			index: true
+		},
+		tags: {
+			type: [String],
+			default: []
+		},
+		convertedContactId: {
+			type: Schema.Types.ObjectId,
+			ref: "Contact"
+		},
+		convertedAccountId: {
+			type: Schema.Types.ObjectId,
+			ref: "Account"
+		},
+		convertedOpportunityId: {
+			type: Schema.Types.ObjectId,
+			ref: "Opportunity"
+		},
+		convertedAt: { type: Date },
+		disqualifyReason: {
+			type: String,
+			trim: true,
+			maxlength: 500
+		},
+		metadata: { type: Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		organizationId: 1,
+		email: 1
+	});
+	schema.index({
+		organizationId: 1,
+		createdAt: -1
+	});
+	schema.index({
+		organizationId: 1,
+		score: -1
+	});
+	return schema;
+}
+function createLeadModel(connection, config) {
+	if (connection.models.Lead) connection.deleteModel("Lead");
+	return connection.model("Lead", buildLeadSchema(config));
+}
+//#endregion
+//#region src/enums/opportunity-status.ts
+/**
+* Top-level opportunity status. Movement through pipeline STAGES
+* happens while status is `open`; `won` / `lost` are terminal
+* outcomes. Re-opening a lost deal is a host-level decision —
+* convention is to clone the opportunity rather than revive the
+* terminal record.
+*/
+const OPPORTUNITY_STATUSES = [
+	"open",
+	"won",
+	"lost",
+	"abandoned"
+];
+const OPPORTUNITY_TRANSITIONS = {
+	open: [
+		"won",
+		"lost",
+		"abandoned"
+	],
+	won: [],
+	lost: [],
+	abandoned: []
+};
+function canTransitionOpportunity(from, to) {
+	return OPPORTUNITY_TRANSITIONS[from].includes(to);
+}
+//#endregion
+//#region src/models/opportunity.schema.ts
+/**
+* Opportunity — qualified deal moving through a Pipeline's stages.
+* Money amount lives flat (`amount` + `currency`) so `$sum` aggregates work; the repo
+* surface returns it that way too (no Money translation layer per PACKAGE_RULES §4).
+*/
+const statusEntrySchema$2 = new Schema({
+	status: {
+		type: String,
+		enum: OPPORTUNITY_STATUSES,
+		required: true
+	},
+	stageId: { type: String },
+	occurredAt: {
+		type: Date,
+		required: true
+	},
+	by: { type: String },
+	note: { type: String }
+}, { _id: false });
+function buildOpportunitySchema(config) {
+	const schema = new Schema({
+		organizationId: tenantFieldDef(config),
+		name: {
+			type: String,
+			required: true,
+			trim: true,
+			maxlength: 200
+		},
+		accountId: {
+			type: Schema.Types.ObjectId,
+			ref: "Account"
+		},
+		primaryContactId: {
+			type: Schema.Types.ObjectId,
+			ref: "Contact"
+		},
+		pipelineId: {
+			type: Schema.Types.ObjectId,
+			ref: "Pipeline",
+			required: true
+		},
+		stageId: {
+			type: String,
+			required: true,
+			index: true
+		},
+		status: {
+			type: String,
+			enum: OPPORTUNITY_STATUSES,
+			default: "open",
+			index: true
+		},
+		statusHistory: {
+			type: [statusEntrySchema$2],
+			default: []
+		},
+		amount: { type: Number },
+		currency: {
+			type: String,
+			default: "USD"
+		},
+		probability: {
+			type: Number,
+			min: 0,
+			max: 1,
+			default: 0
+		},
+		expectedCloseAt: {
+			type: Date,
+			index: true
+		},
+		closedAt: { type: Date },
+		lostReasonId: {
+			type: Schema.Types.ObjectId,
+			ref: "LossReason"
+		},
+		ownerId: {
+			type: String,
+			index: true
+		},
+		sourceLeadId: {
+			type: Schema.Types.ObjectId,
+			ref: "Lead"
+		},
+		tags: {
+			type: [String],
+			default: []
+		},
+		metadata: { type: Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		organizationId: 1,
+		pipelineId: 1,
+		stageId: 1
+	});
+	schema.index({
+		organizationId: 1,
+		status: 1,
+		expectedCloseAt: 1
+	});
+	schema.index({
+		organizationId: 1,
+		ownerId: 1,
+		status: 1
+	});
+	return schema;
+}
+function createOpportunityModel(connection, config) {
+	if (connection.models.Opportunity) connection.deleteModel("Opportunity");
+	return connection.model("Opportunity", buildOpportunitySchema(config));
+}
+//#endregion
+//#region src/models/contact.schema.ts
+/**
+* Contact — a person in the CRM.
+*
+* Per PACKAGE_RULES §4 (no envelopes / no translation): we store the
+* structured `PersonName` + `ContactInfo` from `@classytic/primitives/person`
+* verbatim, embedded. The host queries `contact.name.given`,
+* `contact.contact.email`, etc. directly — no flat-vs-structured
+* translation layer.
+*/
+const nameSchema = new Schema({
+	given: {
+		type: String,
+		required: true,
+		trim: true,
+		maxlength: 100
+	},
+	family: {
+		type: String,
+		default: "",
+		trim: true,
+		maxlength: 100
+	},
+	middle: {
+		type: String,
+		trim: true,
+		maxlength: 100
+	},
+	prefix: {
+		type: String,
+		trim: true,
+		maxlength: 32
+	},
+	suffix: {
+		type: String,
+		trim: true,
+		maxlength: 32
+	},
+	preferred: {
+		type: String,
+		trim: true,
+		maxlength: 100
+	}
+}, { _id: false });
+const contactInfoSchema$1 = new Schema({
+	email: {
+		type: String,
+		trim: true,
+		lowercase: true,
+		maxlength: 255
+	},
+	personalEmail: {
+		type: String,
+		trim: true,
+		lowercase: true,
+		maxlength: 255
+	},
+	phone: {
+		type: String,
+		trim: true,
+		maxlength: 50
+	},
+	alternatePhone: {
+		type: String,
+		trim: true,
+		maxlength: 50
+	}
+}, { _id: false });
+function buildContactSchema(config) {
+	const schema = new Schema({
+		organizationId: tenantFieldDef(config),
+		name: {
+			type: nameSchema,
+			required: true
+		},
+		contact: {
+			type: contactInfoSchema$1,
+			default: {}
+		},
+		jobTitle: {
+			type: String,
+			trim: true,
+			maxlength: 150
+		},
+		accountId: {
+			type: Schema.Types.ObjectId,
+			ref: "Account"
+		},
+		ownerId: {
+			type: String,
+			index: true
+		},
+		tags: {
+			type: [String],
+			default: []
+		},
+		metadata: { type: Schema.Types.Mixed }
+	}, {
+		timestamps: true,
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	schema.index({
+		organizationId: 1,
+		"contact.email": 1
+	});
+	schema.index({
+		organizationId: 1,
+		accountId: 1
+	});
+	schema.index({
+		organizationId: 1,
+		createdAt: -1
+	});
+	schema.index({
+		organizationId: 1,
+		tags: 1
+	});
+	schema.virtual("fullName").get(function() {
+		const n = this.name;
+		return n?.preferred?.trim() || [n?.given, n?.family].filter(Boolean).join(" ");
+	});
+	return schema;
+}
+function createContactModel(connection, config) {
+	if (connection.models.Contact) connection.deleteModel("Contact");
+	return connection.model("Contact", buildContactSchema(config));
+}
+//#endregion
+//#region src/models/account.schema.ts
+/**
+* Account — the B2B customer org an Opportunity targets and Contacts belong to.
+* Flat `annualRevenue` (Number + currency) for $sum aggregations.
+*/
+function buildAccountSchema(config) {
+	const schema = new Schema({
+		organizationId: tenantFieldDef(config),
+		name: {
+			type: String,
+			required: true,
+			trim: true,
+			maxlength: 200
+		},
+		domain: {
+			type: String,
+			trim: true,
+			lowercase: true,
+			maxlength: 255
+		},
+		industry: {
+			type: String,
+			trim: true,
+			maxlength: 100
+		},
+		sizeBucket: {
+			type: String,
+			trim: true,
+			maxlength: 20
+		},
+		annualRevenueAmount: { type: Number },
+		annualRevenueCurrency: {
+			type: String,
+			default: "USD"
+		},
+		ownerId: {
+			type: String,
+			index: true
+		},
+		tags: {
+			type: [String],
+			default: []
+		},
+		metadata: { type: Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		organizationId: 1,
+		domain: 1
+	});
+	schema.index({
+		organizationId: 1,
+		createdAt: -1
+	});
+	schema.index({
+		organizationId: 1,
+		tags: 1
+	});
+	return schema;
+}
+function createAccountModel(connection, config) {
+	if (connection.models.Account) connection.deleteModel("Account");
+	return connection.model("Account", buildAccountSchema(config));
+}
+//#endregion
+//#region src/enums/campaign-status.ts
+/**
+* Campaign lifecycle.
+*
+*   draft     — being built; not running, no sends, no UTM attribution counted
+*   active    — running; participating in attribution + automation
+*   paused    — temporarily halted; can be resumed; no sends fire
+*   completed — finished its run; preserved for historical attribution
+*   archived  — soft-hidden from the default UI; still queryable
+*/
+const CAMPAIGN_STATUSES = [
+	"draft",
+	"active",
+	"paused",
+	"completed",
+	"archived"
+];
+const CAMPAIGN_TRANSITIONS = {
+	draft: ["active", "archived"],
+	active: [
+		"paused",
+		"completed",
+		"archived"
+	],
+	paused: [
+		"active",
+		"completed",
+		"archived"
+	],
+	completed: ["archived"],
+	archived: []
+};
+function canTransitionCampaign(from, to) {
+	return CAMPAIGN_TRANSITIONS[from].includes(to);
+}
+//#endregion
+//#region src/models/campaign.schema.ts
+/**
+* Campaign — a marketing/sales motion targeting a contact list.
+* Money fields stored flat (amount + currency) for $sum aggregations.
+*/
+const statusEntrySchema$1 = new Schema({
+	status: {
+		type: String,
+		enum: CAMPAIGN_STATUSES,
+		required: true
+	},
+	occurredAt: {
+		type: Date,
+		required: true
+	},
+	by: { type: String },
+	note: { type: String }
+}, { _id: false });
+function buildCampaignSchema(config) {
+	const schema = new Schema({
+		organizationId: tenantFieldDef(config),
+		name: {
+			type: String,
+			required: true,
+			trim: true,
+			maxlength: 200
+		},
+		description: {
+			type: String,
+			trim: true,
+			maxlength: 2e3
+		},
+		status: {
+			type: String,
+			enum: CAMPAIGN_STATUSES,
+			default: "draft",
+			index: true
+		},
+		statusHistory: {
+			type: [statusEntrySchema$1],
+			default: []
+		},
+		utmSource: {
+			type: String,
+			trim: true,
+			maxlength: 100
+		},
+		utmMedium: {
+			type: String,
+			trim: true,
+			maxlength: 100
+		},
+		utmCampaign: {
+			type: String,
+			trim: true,
+			maxlength: 100
+		},
+		startDate: { type: Date },
+		endDate: { type: Date },
+		budgetAmount: { type: Number },
+		expectedRevenueAmount: { type: Number },
+		actualRevenueAmount: { type: Number },
+		currency: {
+			type: String,
+			default: "USD"
+		},
+		ownerId: {
+			type: String,
+			index: true
+		},
+		tags: {
+			type: [String],
+			default: []
+		},
+		metadata: { type: Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		organizationId: 1,
+		status: 1
+	});
+	schema.index({
+		organizationId: 1,
+		startDate: 1
+	});
+	schema.index({
+		organizationId: 1,
+		createdAt: -1
+	});
+	schema.index({
+		organizationId: 1,
+		tags: 1
+	});
+	return schema;
+}
+function createCampaignModel(connection, config) {
+	if (connection.models.Campaign) connection.deleteModel("Campaign");
+	return connection.model("Campaign", buildCampaignSchema(config));
+}
+//#endregion
+//#region src/enums/subscription-status.ts
+/**
+* Subscription lifecycle.
+*
+*   pending      — double-opt-in pending confirmation
+*   confirmed    — actively subscribed; eligible to receive sends
+*   unsubscribed — user opted out via unsubscribe link (or operator action)
+*   bounced      — provider reported hard bounce; permanent suppression
+*   complained   — recipient hit "spam" / "report" in their email client;
+*                  permanent suppression (CAN-SPAM + provider trust)
+*
+* All terminal states are non-reopenable. Re-subscribing creates a new
+* Subscription row — the audit trail of unsubscribes/bounces is preserved.
+*/
+const SUBSCRIPTION_STATUSES = [
+	"pending",
+	"confirmed",
+	"unsubscribed",
+	"bounced",
+	"complained"
+];
+const SUBSCRIPTION_TRANSITIONS = {
+	pending: [
+		"confirmed",
+		"unsubscribed",
+		"bounced"
+	],
+	confirmed: [
+		"unsubscribed",
+		"bounced",
+		"complained"
+	],
+	unsubscribed: [],
+	bounced: [],
+	complained: []
+};
+function canTransitionSubscription(from, to) {
+	return SUBSCRIPTION_TRANSITIONS[from].includes(to);
+}
+//#endregion
+//#region src/models/subscription.schema.ts
+/**
+* Subscription — a Contact's opt-in to a Campaign. Double-opt-in tokens,
+* unsubscribe token, compliance audit fields.
+*/
+const statusEntrySchema = new Schema({
+	status: {
+		type: String,
+		enum: SUBSCRIPTION_STATUSES,
+		required: true
+	},
+	occurredAt: {
+		type: Date,
+		required: true
+	},
+	by: { type: String },
+	note: { type: String }
+}, { _id: false });
+function buildSubscriptionSchema(config) {
+	const schema = new Schema({
+		organizationId: tenantFieldDef(config),
+		contactId: {
+			type: Schema.Types.ObjectId,
+			ref: "Contact",
+			required: true
+		},
+		campaignId: {
+			type: Schema.Types.ObjectId,
+			ref: "Campaign",
+			required: true
+		},
+		status: {
+			type: String,
+			enum: SUBSCRIPTION_STATUSES,
+			default: "pending",
+			index: true
+		},
+		statusHistory: {
+			type: [statusEntrySchema],
+			default: []
+		},
+		source: {
+			type: String,
+			trim: true,
+			maxlength: 100
+		},
+		consentTimestamp: {
+			type: Date,
+			required: true
+		},
+		consentIpAddress: {
+			type: String,
+			trim: true,
+			maxlength: 64
+		},
+		consentUserAgent: {
+			type: String,
+			trim: true,
+			maxlength: 500
+		},
+		confirmationToken: {
+			type: String,
+			index: true
+		},
+		unsubscribeToken: {
+			type: String,
+			required: true,
+			index: true
+		},
+		confirmedAt: { type: Date },
+		unsubscribedAt: { type: Date },
+		unsubscribeReason: {
+			type: String,
+			trim: true,
+			maxlength: 500
+		},
+		bouncedAt: { type: Date },
+		bounceReason: {
+			type: String,
+			trim: true,
+			maxlength: 500
+		},
+		complainedAt: { type: Date },
+		metadata: { type: Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		organizationId: 1,
+		campaignId: 1,
+		status: 1
+	});
+	schema.index({
+		organizationId: 1,
+		contactId: 1,
+		campaignId: 1
+	});
+	schema.index({
+		organizationId: 1,
+		createdAt: -1
+	});
+	return schema;
+}
+function createSubscriptionModel(connection, config) {
+	if (connection.models.Subscription) connection.deleteModel("Subscription");
+	return connection.model("Subscription", buildSubscriptionSchema(config));
+}
+//#endregion
+//#region src/enums/activity.ts
+/**
+* Activity type vocabulary. The package stores `type` as free-form
+* string so hosts can extend; these constants cover the common
+* channels that automation tooling typically keys off.
+*/
+const ACTIVITY_TYPES = [
+	"call",
+	"email",
+	"meeting",
+	"task",
+	"note",
+	"sms",
+	"social",
+	"demo",
+	"other"
+];
+const ACTIVITY_STATUSES = [
+	"planned",
+	"in_progress",
+	"completed",
+	"cancelled"
+];
+const ACTIVITY_TRANSITIONS = {
+	planned: [
+		"in_progress",
+		"completed",
+		"cancelled"
+	],
+	in_progress: ["completed", "cancelled"],
+	completed: [],
+	cancelled: []
+};
+function canTransitionActivity(from, to) {
+	return ACTIVITY_TRANSITIONS[from].includes(to);
+}
+/**
+* Kinds of entity an Activity can reference. Polymorphic linking lets
+* hosts log a call against a Lead, an Opportunity, a Contact, or a
+* stand-alone Account.
+*/
+const SUBJECT_KINDS = [
+	"lead",
+	"opportunity",
+	"contact",
+	"account"
+];
+//#endregion
+//#region src/models/activity.schema.ts
+/**
+* Activity — call / email / meeting / task tied polymorphically to a CRM subject
+* (Contact / Lead / Opportunity / Account).
+*/
+function buildActivitySchema(config) {
+	const schema = new Schema({
+		organizationId: tenantFieldDef(config),
+		type: {
+			type: String,
+			enum: ACTIVITY_TYPES,
+			required: true,
+			index: true
+		},
+		status: {
+			type: String,
+			enum: ACTIVITY_STATUSES,
+			default: "planned",
+			index: true
+		},
+		subjectKind: {
+			type: String,
+			enum: SUBJECT_KINDS,
+			required: true
+		},
+		subjectId: {
+			type: Schema.Types.ObjectId,
+			required: true,
+			index: true
+		},
+		title: {
+			type: String,
+			required: true,
+			trim: true,
+			maxlength: 200
+		},
+		description: {
+			type: String,
+			trim: true,
+			maxlength: 2e3
+		},
+		ownerId: {
+			type: String,
+			index: true
+		},
+		participantIds: {
+			type: [String],
+			default: []
+		},
+		dueDate: {
+			type: Date,
+			index: true
+		},
+		completedAt: { type: Date },
+		externalRef: {
+			type: String,
+			trim: true,
+			maxlength: 200
+		},
+		metadata: { type: Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		organizationId: 1,
+		subjectKind: 1,
+		subjectId: 1
+	});
+	schema.index({
+		organizationId: 1,
+		status: 1,
+		dueDate: 1
+	});
+	schema.index({
+		organizationId: 1,
+		ownerId: 1,
+		status: 1
+	});
+	schema.index({
+		organizationId: 1,
+		type: 1
+	});
+	schema.index({
+		organizationId: 1,
+		createdAt: -1
+	});
+	return schema;
+}
+function createActivityModel(connection, config) {
+	if (connection.models.Activity) connection.deleteModel("Activity");
+	return connection.model("Activity", buildActivitySchema(config));
+}
+//#endregion
+//#region src/models/note.schema.ts
+/**
+* Note — free-form annotation tied polymorphically to a CRM subject.
+* Separate from Activity because notes don't have a lifecycle (no
+* planned/completed/cancelled).
+*/
+function buildNoteSchema(config) {
+	const schema = new Schema({
+		organizationId: tenantFieldDef(config),
+		subjectKind: {
+			type: String,
+			enum: SUBJECT_KINDS,
+			required: true
+		},
+		subjectId: {
+			type: Schema.Types.ObjectId,
+			required: true,
+			index: true
+		},
+		body: {
+			type: String,
+			required: true,
+			trim: true,
+			maxlength: 1e4
+		},
+		authorId: {
+			type: String,
+			index: true
+		},
+		pinned: {
+			type: Boolean,
+			default: false,
+			index: true
+		},
+		metadata: { type: Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		organizationId: 1,
+		subjectKind: 1,
+		subjectId: 1,
+		pinned: -1,
+		createdAt: -1
+	});
+	return schema;
+}
+function createNoteModel(connection, config) {
+	if (connection.models.Note) connection.deleteModel("Note");
+	return connection.model("Note", buildNoteSchema(config));
+}
+//#endregion
+//#region src/models/loss-reason.schema.ts
+/**
+* LossReason — per-org taxonomy for "why did this deal die?" Referenced
+* by `Opportunity.lostReasonId` on `lose()` transitions for forecast +
+* win-loss reporting.
+*/
+function buildLossReasonSchema(config) {
+	const schema = new Schema({
+		organizationId: tenantFieldDef(config),
+		name: {
+			type: String,
+			required: true,
+			trim: true,
+			maxlength: 200
+		},
+		description: {
+			type: String,
+			trim: true,
+			maxlength: 1e3
+		},
+		isActive: {
+			type: Boolean,
+			default: true,
+			index: true
+		},
+		sequence: {
+			type: Number,
+			default: 0
+		},
+		metadata: { type: Schema.Types.Mixed }
+	}, { timestamps: true });
+	schema.index({
+		organizationId: 1,
+		isActive: 1,
+		sequence: 1
+	});
+	return schema;
+}
+function createLossReasonModel(connection, config) {
+	if (connection.models.LossReason) connection.deleteModel("LossReason");
+	return connection.model("LossReason", buildLossReasonSchema(config));
+}
+//#endregion
+//#region src/enums/email-event-kind.ts
+/**
+* Email engagement event kinds, recorded against a Contact / Campaign /
+* Subscription tuple as the recipient interacts with a sent message.
+*
+*   open       — recipient's mail client loaded the tracking pixel.
+*                Imperfect signal: image-block clients suppress it, some
+*                clients pre-fetch and inflate counts. Useful in aggregate.
+*
+*   click      — recipient followed a tracked link. High-signal: actual
+*                user action, not background fetch.
+*
+*   bounce     — provider reported delivery failed. Pair with the
+*                `bounce` status on Subscription for permanent suppression.
+*
+*   complaint  — recipient hit "spam" / "report" in their inbox. Pair
+*                with `complained` Subscription status.
+*
+*   unsubscribe — recipient hit the unsubscribe link in the email. May
+*                fire BEFORE the Subscription itself is marked unsubscribed
+*                (the host can choose to confirm before flipping status).
+*
+* Open and click are "engagement signal"; bounce/complaint/unsubscribe are
+* "suppression signal". The service exposes aggregates over both
+* categories so consumers can compute open rate, click rate, bounce rate
+* without filtering kind themselves.
+*/
+const EMAIL_EVENT_KINDS = [
+	"open",
+	"click",
+	"bounce",
+	"complaint",
+	"unsubscribe"
+];
+//#endregion
+//#region src/models/email-event.schema.ts
+/**
+* EmailEvent — append-only engagement / suppression log per recipient.
+*
+* Open / click / bounce / complaint / unsubscribe — all surface against
+* a polymorphic subject (Contact OR Subscription). Aggregates power
+* drip-sequence branches ("if opened") + campaign analytics.
+*/
+const EMAIL_EVENT_SUBJECT_KINDS = ["contact", "subscription"];
+function buildEmailEventSchema(config) {
+	const schema = new Schema({
+		organizationId: tenantFieldDef(config),
+		kind: {
+			type: String,
+			enum: EMAIL_EVENT_KINDS,
+			required: true,
+			index: true
+		},
+		subjectKind: {
+			type: String,
+			enum: EMAIL_EVENT_SUBJECT_KINDS,
+			required: true
+		},
+		subjectId: {
+			type: Schema.Types.ObjectId,
+			required: true,
+			index: true
+		},
+		campaignId: {
+			type: Schema.Types.ObjectId,
+			ref: "Campaign",
+			index: true
+		},
+		messageId: {
+			type: String,
+			trim: true,
+			maxlength: 200
+		},
+		url: {
+			type: String,
+			trim: true,
+			maxlength: 2048
+		},
+		userAgent: {
+			type: String,
+			trim: true,
+			maxlength: 500
+		},
+		ip: {
+			type: String,
+			trim: true,
+			maxlength: 64
+		},
+		metadata: { type: Schema.Types.Mixed }
+	}, { timestamps: {
+		createdAt: true,
+		updatedAt: false
+	} });
+	schema.index({
+		organizationId: 1,
+		createdAt: -1
+	});
+	schema.index({
+		organizationId: 1,
+		subjectKind: 1,
+		subjectId: 1,
+		createdAt: -1
+	});
+	schema.index({
+		organizationId: 1,
+		campaignId: 1,
+		kind: 1,
+		createdAt: -1
+	});
+	schema.index({
+		organizationId: 1,
+		messageId: 1
+	});
+	return schema;
+}
+function createEmailEventModel(connection, config) {
+	if (connection.models.EmailEvent) connection.deleteModel("EmailEvent");
+	return connection.model("EmailEvent", buildEmailEventSchema(config));
+}
+//#endregion
+//#region src/models/create-models.ts
+function createCrmModels(connection, config) {
+	return Object.freeze({
+		Pipeline: createPipelineModel(connection, config),
+		Lead: createLeadModel(connection, config),
+		Opportunity: createOpportunityModel(connection, config),
+		Contact: createContactModel(connection, config),
+		Account: createAccountModel(connection, config),
+		Campaign: createCampaignModel(connection, config),
+		Subscription: createSubscriptionModel(connection, config),
+		Activity: createActivityModel(connection, config),
+		Note: createNoteModel(connection, config),
+		LossReason: createLossReasonModel(connection, config),
+		EmailEvent: createEmailEventModel(connection, config)
+	});
+}
+//#endregion
+//#region src/core/errors.ts
 /**
 * CRM error vocabulary. Hosts catch `CrmError` at API edges.
 */
@@ -58,16 +1329,36 @@ var EmptyPipelineError = class extends CrmError {
 		super("EMPTY_PIPELINE", `Pipeline '${pipelineId}' has no stages`, { pipelineId });
 	}
 };
-//#endregion
-//#region src/domain/ports/clock.port.ts
-const systemClock = { now: () => /* @__PURE__ */ new Date() };
-//#endregion
-//#region src/adapters/in-memory/id-generator.ts
-const cryptoIdGenerator = { next: () => randomUUID() };
-function createSequentialIdGenerator(prefix = "id_") {
-	let n = 0;
-	return { next: () => `${prefix}${++n}` };
-}
+var InvalidCampaignTransitionError = class extends CrmError {
+	constructor(details) {
+		super("INVALID_CAMPAIGN_TRANSITION", `Campaign ${details.campaignId} cannot move from '${details.from}' to '${details.to}'`, details);
+	}
+};
+var DuplicateCampaignError = class extends CrmError {
+	constructor(name) {
+		super("DUPLICATE_CAMPAIGN", `A campaign named '${name}' already exists`, { name });
+	}
+};
+var InvalidSubscriptionTransitionError = class extends CrmError {
+	constructor(details) {
+		super("INVALID_SUBSCRIPTION_TRANSITION", `Subscription ${details.subscriptionId} cannot move from '${details.from}' to '${details.to}'`, details);
+	}
+};
+var DuplicateSubscriptionError = class extends CrmError {
+	constructor(details) {
+		super("DUPLICATE_SUBSCRIPTION", `Contact '${details.contactId}' already has a live subscription on campaign '${details.campaignId}'`, details);
+	}
+};
+var InvalidConfirmationTokenError = class extends CrmError {
+	constructor() {
+		super("INVALID_CONFIRMATION_TOKEN", "No subscription matches the supplied confirmation token, or it has already been used");
+	}
+};
+var InvalidUnsubscribeTokenError = class extends CrmError {
+	constructor() {
+		super("INVALID_UNSUBSCRIBE_TOKEN", "No subscription matches the supplied unsubscribe token");
+	}
+};
 //#endregion
 //#region src/events/event-constants.ts
 /** PACKAGE_RULES rule 12: `package:resource.verb`. */
@@ -92,420 +1383,166 @@ const CRM_EVENTS = {
 	ACTIVITY_PLANNED: "crm:activity.planned",
 	ACTIVITY_COMPLETED: "crm:activity.completed",
 	ACTIVITY_CANCELLED: "crm:activity.cancelled",
-	NOTE_ADDED: "crm:note.added"
+	NOTE_ADDED: "crm:note.added",
+	CAMPAIGN_CREATED: "crm:campaign.created",
+	CAMPAIGN_ACTIVATED: "crm:campaign.activated",
+	CAMPAIGN_PAUSED: "crm:campaign.paused",
+	CAMPAIGN_RESUMED: "crm:campaign.resumed",
+	CAMPAIGN_COMPLETED: "crm:campaign.completed",
+	CAMPAIGN_ARCHIVED: "crm:campaign.archived",
+	SUBSCRIPTION_CREATED: "crm:subscription.created",
+	SUBSCRIPTION_CONFIRMED: "crm:subscription.confirmed",
+	SUBSCRIPTION_UNSUBSCRIBED: "crm:subscription.unsubscribed",
+	SUBSCRIPTION_BOUNCED: "crm:subscription.bounced",
+	SUBSCRIPTION_COMPLAINED: "crm:subscription.complained",
+	EMAIL_EVENT_OPENED: "crm:email_event.opened",
+	EMAIL_EVENT_CLICKED: "crm:email_event.clicked",
+	EMAIL_EVENT_BOUNCED: "crm:email_event.bounced",
+	EMAIL_EVENT_COMPLAINED: "crm:email_event.complained",
+	EMAIL_EVENT_UNSUBSCRIBED: "crm:email_event.unsubscribed"
 };
 //#endregion
-//#region src/events/publish.ts
+//#region src/events/helpers.ts
 /**
-* Emit a CRM domain event through the host's infrastructure.
-*
-* Three independent seams, all optional:
-*
-*   - `transport` — `EventTransport` (Kafka / SQS / Redis / in-process).
-*     When present, the event is delivered via `transport.publish(event)`.
-*   - `outbox`    — `OutboxStore` (any backend implementing the primitives
-*     contract — a host-owned mongo `event_outbox` collection, an arc
-*     `repositoryAsOutboxStore(repo)` adapter, or a custom adapter). When
-*     present, the event is persisted via `outbox.save(event, { session })`
-*     **before** the transport publish so durable at-least-once delivery
-*     is guaranteed even when the transport is down.
-*   - `session`   — any DB transaction handle the host is running. Threaded
-*     into `outbox.save(event, { session })` so the outbox row commits
-*     atomically with the host's business write. Typed `unknown` to keep
-*     crm framework-agnostic.
-*
-* Error semantics:
+* Event creation helper.
 *
-*   - Outbox errors **propagate**. When the host wraps the whole call in
-*     `session.withTransaction(...)`, an outbox-save failure will abort
-*     the transaction (business write rolls back with the missing outbox
-*     row) — this is the desired atomicity. For the no-session case, the
-*     caller handles the error.
-*   - Transport errors are **logged and swallowed**. When an outbox is
-*     wired the host's relay guarantees redelivery, so a flaky transport
-*     must not block the request.
+* Thin wrapper around `@classytic/primitives`' `createEvent` that fills the
+* shared `EventMeta` from a `CrmContext` (userId/actorId, organizationId,
+* correlationId). Use this instead of importing `createEvent` directly so
+* the `source: 'crm'` stamp + tenant scoping stay consistent.
 */
-async function emitCrmEvent(transport, outbox, type, payload, meta = {}, session) {
-	if (!transport && !outbox) return;
-	const event = createEvent(type, payload, {
+function createEvent(type, payload, ctx, meta) {
+	return createEvent$1(type, payload, {
 		source: "crm",
+		...ctx?.actorId !== void 0 ? { actorId: String(ctx.actorId) } : {},
+		...ctx?.organizationId !== void 0 ? { organizationId: String(ctx.organizationId) } : {},
+		...ctx?.correlationId !== void 0 ? { correlationId: ctx.correlationId } : {},
 		...meta
 	});
-	if (outbox) await outbox.save(event, session !== void 0 ? { session } : {});
-	if (transport) try {
-		await transport.publish(event);
-	} catch (err) {
-		console.error(`[crm] events.publish failed for ${event.type}:`, err);
-	}
-}
-//#endregion
-//#region src/services/account.service.ts
-var AccountService = class {
-	repo;
-	events;
-	outbox;
-	clock;
-	ids;
-	constructor(config) {
-		this.repo = config.repo;
-		this.events = config.events;
-		this.outbox = config.outbox;
-		this.clock = config.clock ?? systemClock;
-		this.ids = config.ids ?? cryptoIdGenerator;
-	}
-	async create(input, options = {}) {
-		const account = await this.repo.create({
-			id: this.ids.next(),
-			name: input.name,
-			...input.domain !== void 0 ? { domain: input.domain } : {},
-			...input.industry !== void 0 ? { industry: input.industry } : {},
-			...input.sizeBucket !== void 0 ? { sizeBucket: input.sizeBucket } : {},
-			...input.annualRevenue !== void 0 ? { annualRevenue: input.annualRevenue } : {},
-			...input.ownerId !== void 0 ? { ownerId: input.ownerId } : {},
-			...input.tags !== void 0 ? { tags: input.tags } : {},
-			...input.metadata !== void 0 ? { metadata: input.metadata } : {}
-		});
-		if (options.emitEvents !== false) await this._emit(CRM_EVENTS.ACCOUNT_CREATED, { accountId: account.id }, {
-			resource: "account",
-			resourceId: account.id
-		}, options);
-		return account;
-	}
-	async update(id, patch, options = {}) {
-		await this._require(id);
-		const updated = await this.repo.update(id, patch);
-		if (options.emitEvents !== false) await this._emit(CRM_EVENTS.ACCOUNT_UPDATED, { accountId: id }, {
-			resource: "account",
-			resourceId: id
-		}, options);
-		return updated;
-	}
-	async delete(id) {
-		await this._require(id);
-		await this.repo.delete(id);
-	}
-	findById(id) {
-		return this.repo.findById(id);
-	}
-	findByDomain(domain) {
-		return this.repo.findByDomain(domain);
-	}
-	list(filter) {
-		return this.repo.list(filter);
-	}
-	async _require(id) {
-		const a = await this.repo.findById(id);
-		if (!a) throw new NotFoundError("account", id);
-		return a;
-	}
-	async _emit(event, payload, meta, options = {}) {
-		await emitCrmEvent(this.events, this.outbox, event, payload, meta, options.session);
-	}
-};
-//#endregion
-//#region src/domain/enums/activity.ts
-/**
-* Activity type vocabulary. The package stores `type` as free-form
-* string so hosts can extend; these constants cover the common
-* channels that automation tooling typically keys off.
-*/
-const ACTIVITY_TYPES = [
-	"call",
-	"email",
-	"meeting",
-	"task",
-	"note",
-	"sms",
-	"social",
-	"demo",
-	"other"
-];
-const ACTIVITY_STATUSES = [
-	"planned",
-	"in_progress",
-	"completed",
-	"cancelled"
-];
-const ACTIVITY_TRANSITIONS = {
-	planned: [
-		"in_progress",
-		"completed",
-		"cancelled"
-	],
-	in_progress: ["completed", "cancelled"],
-	completed: [],
-	cancelled: []
-};
-function canTransitionActivity(from, to) {
-	return ACTIVITY_TRANSITIONS[from].includes(to);
 }
-/**
-* Kinds of entity an Activity can reference. Polymorphic linking lets
-* hosts log a call against a Lead, an Opportunity, a Contact, or a
-* stand-alone Account.
-*/
-const SUBJECT_KINDS = [
-	"lead",
-	"opportunity",
-	"contact",
-	"account"
-];
 //#endregion
-//#region src/services/activity.service.ts
-/**
-* Polymorphic activity / note service. Activities have a lifecycle
-* (`planned → in_progress → completed | cancelled`); notes are
-* immutable-ish (create + update body, no status).
-*/
-var ActivityService = class {
-	repo;
-	noteRepo;
+//#region src/repositories/pipeline.repository.ts
+var PipelineRepository = class extends Repository {
 	events;
-	outbox;
-	clock;
-	ids;
-	constructor(config) {
-		this.repo = config.repo;
-		this.noteRepo = config.notes;
-		this.events = config.events;
-		this.outbox = config.outbox;
-		this.clock = config.clock ?? systemClock;
-		this.ids = config.ids ?? cryptoIdGenerator;
-	}
-	async plan(input, options = {}) {
-		const activity = await this.repo.create({
-			id: this.ids.next(),
-			type: input.type,
-			status: "planned",
-			subjectKind: input.subjectKind,
-			subjectId: input.subjectId,
-			...input.subject !== void 0 ? { subject: input.subject } : {},
-			...input.body !== void 0 ? { body: input.body } : {},
-			...input.scheduledAt !== void 0 ? { scheduledAt: input.scheduledAt } : {},
-			...input.ownerId !== void 0 ? { ownerId: input.ownerId } : {},
-			...input.participantIds !== void 0 ? { participantIds: input.participantIds } : {},
-			...input.externalRef !== void 0 ? { externalRef: input.externalRef } : {},
-			...input.metadata !== void 0 ? { metadata: input.metadata } : {}
-		});
-		await this._emit(CRM_EVENTS.ACTIVITY_PLANNED, {
-			activityId: activity.id,
-			type: activity.type,
-			subjectKind: activity.subjectKind,
-			subjectId: activity.subjectId
-		}, {
-			resource: "activity",
-			resourceId: activity.id
-		}, options);
-		return activity;
-	}
-	async start(id, options = {}) {
-		return this._transition(id, "in_progress", {}, options);
-	}
-	async complete(id, completedAt, options = {}) {
-		const now = completedAt ?? this.clock.now();
-		const updated = await this._transition(id, "completed", { completedAt: now }, options);
-		await this._emit(CRM_EVENTS.ACTIVITY_COMPLETED, {
-			activityId: id,
-			completedAt: now
-		}, {
-			resource: "activity",
-			resourceId: id
-		}, options);
-		return updated;
-	}
-	async cancel(id, reason, options = {}) {
-		const patch = { cancelledAt: this.clock.now() };
-		if (reason !== void 0) patch.metadata = {
-			...patch.metadata ?? {},
-			cancelReason: reason
-		};
-		const updated = await this._transition(id, "cancelled", patch, options);
-		await this._emit(CRM_EVENTS.ACTIVITY_CANCELLED, {
-			activityId: id,
-			reason
-		}, {
-			resource: "activity",
-			resourceId: id
-		}, options);
-		return updated;
-	}
-	async addNote(input, options = {}) {
-		const note = await this.noteRepo.create({
-			id: this.ids.next(),
-			subjectKind: input.subjectKind,
-			subjectId: input.subjectId,
-			body: input.body,
-			format: input.format ?? "plain",
-			...input.authorId !== void 0 ? { authorId: input.authorId } : {},
-			...input.metadata !== void 0 ? { metadata: input.metadata } : {}
-		});
-		await this._emit(CRM_EVENTS.NOTE_ADDED, {
-			noteId: note.id,
-			subjectKind: note.subjectKind,
-			subjectId: note.subjectId
-		}, {
-			resource: "note",
-			resourceId: note.id
-		}, options);
-		return note;
-	}
-	listBySubject(subjectKind, subjectId) {
-		return this.repo.list({
-			subjectKind,
-			subjectId
+	constructor(model, plugins, deps, pagination) {
+		super(model, plugins, pagination);
+		this.events = deps.events;
+	}
+	/**
+	* Read a single embedded stage. Used by Opportunity create / move to
+	* validate stage membership + pick up `defaultProbability`.
+	*/
+	async getStage(pipelineId, stageId, ctx) {
+		const pipeline = await this.getById(pipelineId, ctx);
+		if (!pipeline) throw new NotFoundError("Pipeline", pipelineId);
+		if (pipeline.stages.length === 0) throw new EmptyPipelineError(pipelineId);
+		const stage = pipeline.stages.find((s) => String(s._id) === stageId);
+		if (!stage) throw new StageNotInPipelineError({
+			pipelineId,
+			stageId
 		});
+		return stage;
 	}
-	listNotesBySubject(subjectKind, subjectId) {
-		return this.noteRepo.listBySubject(subjectKind, subjectId);
-	}
-	findById(id) {
-		return this.repo.findById(id);
-	}
-	async _transition(id, target, patch = {}, _options = {}) {
-		const existing = await this.repo.findById(id);
-		if (!existing) throw new NotFoundError("activity", id);
-		if (!canTransitionActivity(existing.status, target)) throw new InvalidActivityTransitionError({
-			from: existing.status,
-			to: target,
-			activityId: id
-		});
-		const updated = await this.repo.casStatus(id, existing.status, target, patch);
-		if (!updated) throw new InvalidActivityTransitionError({
-			from: existing.status,
-			to: target,
-			activityId: id
+	/** First stage by `sequence` ascending. */
+	async getFirstStage(pipelineId, ctx) {
+		const pipeline = await this.getById(pipelineId, ctx);
+		if (!pipeline) throw new NotFoundError("Pipeline", pipelineId);
+		if (pipeline.stages.length === 0) throw new EmptyPipelineError(pipelineId);
+		return [...pipeline.stages].sort((a, b) => a.sequence - b.sequence)[0];
+	}
+	/** Stage immediately after the given one. `null` at terminal stage. */
+	async getNextStage(pipelineId, stageId, ctx) {
+		const pipeline = await this.getById(pipelineId, ctx);
+		if (!pipeline) throw new NotFoundError("Pipeline", pipelineId);
+		const ordered = [...pipeline.stages].sort((a, b) => a.sequence - b.sequence);
+		const idx = ordered.findIndex((s) => String(s._id) === stageId);
+		if (idx === -1) throw new StageNotInPipelineError({
+			pipelineId,
+			stageId
 		});
-		return updated;
-	}
-	async _emit(event, payload, meta, options = {}) {
-		await emitCrmEvent(this.events, this.outbox, event, payload, meta, options.session);
+		return ordered[idx + 1] ?? null;
 	}
-};
-//#endregion
-//#region src/services/contact.service.ts
-var ContactService = class {
-	repo;
-	events;
-	outbox;
-	clock;
-	ids;
-	constructor(config) {
-		this.repo = config.repo;
-		this.events = config.events;
-		this.outbox = config.outbox;
-		this.clock = config.clock ?? systemClock;
-		this.ids = config.ids ?? cryptoIdGenerator;
-	}
-	async create(input, options = {}) {
-		const contact = await this.repo.create({
-			id: this.ids.next(),
-			name: input.name,
-			contact: input.contact ?? {},
-			...input.jobTitle !== void 0 ? { jobTitle: input.jobTitle } : {},
-			...input.accountId !== void 0 ? { accountId: input.accountId } : {},
-			...input.ownerId !== void 0 ? { ownerId: input.ownerId } : {},
-			...input.tags !== void 0 ? { tags: input.tags } : {},
-			...input.metadata !== void 0 ? { metadata: input.metadata } : {}
-		});
-		if (options.emitEvents !== false) await this._emit(CRM_EVENTS.CONTACT_CREATED, {
-			contactId: contact.id,
-			email: contact.contact.email
-		}, {
-			resource: "contact",
-			resourceId: contact.id
-		}, options);
-		return contact;
-	}
-	async update(id, patch, options = {}) {
-		await this._require(id);
-		const updated = await this.repo.update(id, patch);
-		if (options.emitEvents !== false) await this._emit(CRM_EVENTS.CONTACT_UPDATED, { contactId: id }, {
-			resource: "contact",
-			resourceId: id
-		}, options);
+	/** Soft-deprecate — existing opps still move; no new ones can be created. */
+	async archive(id, ctx) {
+		const updated = await this.update(id, { isArchived: true }, ctx);
+		if (!updated) throw new NotFoundError("Pipeline", id);
+		await this.events.publish(createEvent(CRM_EVENTS.PIPELINE_ARCHIVED, { pipelineId: id }, ctx));
 		return updated;
 	}
-	async delete(id) {
-		await this._require(id);
-		await this.repo.delete(id);
-	}
-	findById(id) {
-		return this.repo.findById(id);
-	}
-	findByEmail(email) {
-		return this.repo.findByEmail(email);
-	}
-	list(filter) {
-		return this.repo.list(filter);
-	}
-	async _require(id) {
-		const c = await this.repo.findById(id);
-		if (!c) throw new NotFoundError("contact", id);
-		return c;
-	}
-	async _emit(event, payload, meta, options = {}) {
-		await emitCrmEvent(this.events, this.outbox, event, payload, meta, options.session);
-	}
 };
 //#endregion
-//#region src/domain/enums/lead-status.ts
+//#region src/core/state-machines.ts
 /**
-* Lead lifecycle — from initial inquiry through conversion.
+* Declarative state machines for every CRM aggregate that has lifecycle
+* transitions. Single source of truth for what `from -> to` moves are
+* legal — the repositories' domain verbs (`qualify`, `convert`, `win`,
+* `lose`, `confirm`, `unsubscribe`, ...) call `assertTransition` before
+* they touch Mongo.
 *
-*   new          — just captured (web form, import, referral)
-*   contacted    — SDR has reached out
-*   qualified    — meets ICP / BANT
-*   converted    — turned into Contact + Account + Opportunity
-*   disqualified — rejected (bad fit, spam, duplicate)
-*   nurturing    — not ready now; parked for later outreach
+* Per PACKAGE_RULES §30: "State machines map to Arc Actions". The host
+* exposes each domain verb as an arc Action (`POST /:id/action` with
+* `{ action: 'qualify' }`); the verb's implementation lives on the
+* Repository class and uses these machines internally.
+*
+* Built on `@classytic/primitives/state-machine` so the same shape lights
+* up across kits (mongokit's `claim()` pairing, sqlitekit follow-ups).
 */
-const LEAD_STATUSES = [
-	"new",
-	"contacted",
-	"qualified",
-	"converted",
-	"disqualified",
-	"nurturing"
-];
-const LEAD_TRANSITIONS = {
-	new: [
-		"contacted",
-		"qualified",
-		"disqualified",
-		"nurturing"
-	],
-	contacted: [
-		"qualified",
-		"disqualified",
-		"nurturing"
-	],
-	qualified: [
-		"converted",
-		"disqualified",
-		"nurturing"
-	],
-	nurturing: [
-		"contacted",
-		"qualified",
-		"disqualified"
-	],
-	converted: [],
-	disqualified: []
-};
-function canTransitionLead(from, to) {
-	return LEAD_TRANSITIONS[from].includes(to);
-}
+const LEAD_MACHINE = defineStateMachine({
+	name: "Lead",
+	transitions: LEAD_TRANSITIONS,
+	errorFactory: ({ entityId, from, to }) => new InvalidLeadTransitionError({
+		from,
+		to,
+		leadId: entityId
+	})
+});
+const OPPORTUNITY_MACHINE = defineStateMachine({
+	name: "Opportunity",
+	transitions: OPPORTUNITY_TRANSITIONS,
+	errorFactory: ({ entityId, from, to }) => new InvalidOpportunityTransitionError({
+		from,
+		to,
+		opportunityId: entityId
+	})
+});
+const CAMPAIGN_MACHINE = defineStateMachine({
+	name: "Campaign",
+	transitions: CAMPAIGN_TRANSITIONS,
+	errorFactory: ({ entityId, from, to }) => new InvalidCampaignTransitionError({
+		from,
+		to,
+		campaignId: entityId
+	})
+});
+const SUBSCRIPTION_MACHINE = defineStateMachine({
+	name: "Subscription",
+	transitions: SUBSCRIPTION_TRANSITIONS,
+	errorFactory: ({ entityId, from, to }) => new InvalidSubscriptionTransitionError({
+		from,
+		to,
+		subscriptionId: entityId
+	})
+});
+const ACTIVITY_MACHINE = defineStateMachine({
+	name: "Activity",
+	transitions: ACTIVITY_TRANSITIONS,
+	errorFactory: ({ entityId, from, to }) => new InvalidActivityTransitionError({
+		from,
+		to,
+		activityId: entityId
+	})
+});
 //#endregion
-//#region src/services/scoring.ts
+//#region src/shared/calculators/scoring.ts
 /**
-* Reference implementation. Intentionally simple so hosts read it and
-* understand the shape, then replace it.
+* Reference implementation. Intentionally simple — hosts read it and
+* replace it.
 *
 * +20 if email is present
 * +20 if phone is present
 * +20 if companyName is present
 * +10 per populated tag up to 40
-* +10 if jobTitle looks director/manager/head (case-insensitive)
+* +10 if jobTitle hints senior (director / manager / head / chief / vp / founder)
 */
 function defaultLeadScorer(lead) {
 	let score = 0;
@@ -513,631 +1550,1022 @@ function defaultLeadScorer(lead) {
 	if (lead.phone) score += 20;
 	if (lead.companyName) score += 20;
 	score += Math.min(40, (lead.tags?.length ?? 0) * 10);
-	if (lead.jobTitle && /(director|manager|head|chief|vp|founder)/i.test(lead.jobTitle)) score += 10;
-	return score;
-}
-/**
-* Compose a scoring pipeline — each rule returns an increment
-* (positive or negative). Useful when host logic is a bunch of
-* small, testable rules.
-*
-* @example
-* ```ts
-* const scorer = composeScorers(
-*   (l) => (l.email ? 20 : 0),
-*   (l) => (l.source === 'referral' ? 30 : 0),
-*   (l) => (l.tags?.includes('enterprise') ? 50 : 0),
-* );
-* ```
-*/
-function composeScorers(...rules) {
-	return (lead) => rules.reduce((acc, r) => acc + r(lead), 0);
-}
-//#endregion
-//#region src/services/lead.service.ts
-/**
-* Derive a `PersonName` from a Lead's flat fields. Leads usually arrive from
-* web forms where the capture is either a split `firstName`/`lastName` or a
-* single `fullName` string — we support both without forcing callers to
-* normalise upstream.
-*/
-function splitLeadName(lead) {
-	if (lead.firstName || lead.lastName) return {
-		given: lead.firstName ?? "",
-		family: lead.lastName ?? "",
-		...lead.fullName && lead.fullName !== `${lead.firstName ?? ""} ${lead.lastName ?? ""}`.trim() ? { preferred: lead.fullName } : {}
-	};
-	const parts = (lead.fullName ?? "").trim().split(/\s+/);
-	if (parts.length <= 1) return {
-		given: parts[0] ?? "Unknown",
-		family: ""
-	};
-	const family = parts.pop() ?? "";
-	return {
-		given: parts.join(" "),
-		family
-	};
+	if (lead.jobTitle && /(director|manager|head|chief|vp|founder)/i.test(lead.jobTitle)) score += 10;
+	return score;
 }
-/**
-* Lead lifecycle + the crown-jewel `convert()` verb that atomically
-* spawns a Contact + Account + Opportunity and transitions the lead
-* to `converted`.
-*/
-var LeadService = class {
-	repo;
-	contacts;
-	accounts;
-	opportunities;
+/** Compose multiple small rules into one scorer. */
+function composeScorers(...rules) {
+	return (lead) => rules.reduce((acc, r) => acc + r(lead), 0);
+}
+//#endregion
+//#region src/repositories/lead.repository.ts
+var LeadRepository = class extends Repository {
 	events;
-	outbox;
-	clock;
-	ids;
 	scorer;
 	rejectDuplicates;
-	constructor(config) {
-		this.repo = config.repo;
-		this.contacts = config.contacts;
-		this.accounts = config.accounts;
-		this.opportunities = config.opportunities;
-		this.events = config.events;
-		this.outbox = config.outbox;
-		this.clock = config.clock ?? systemClock;
-		this.ids = config.ids ?? cryptoIdGenerator;
-		this.scorer = config.scorer ?? defaultLeadScorer;
-		this.rejectDuplicates = config.rejectDuplicates ?? true;
-	}
-	async create(input, options = {}) {
+	constructor(model, plugins, deps, pagination) {
+		super(model, plugins, pagination);
+		this.events = deps.events;
+		this.scorer = deps.scorer ?? defaultLeadScorer;
+		this.rejectDuplicates = deps.rejectDuplicates ?? true;
+	}
+	/**
+	* Create a Lead. Auto-scores on insert so hosts can route immediately.
+	* Rejects duplicate emails inside the same tenant unless
+	* `rejectDuplicates: false` was set at engine boot.
+	*/
+	async createLead(input, ctx) {
 		if (this.rejectDuplicates && input.email) {
-			if (await this.repo.findByEmail(input.email)) throw new DuplicateLeadError({ email: input.email });
+			if (await this.getOne({ email: input.email }, ctx)) throw new DuplicateLeadError({ email: input.email });
 		}
-		const now = this.clock.now();
-		const fullName = input.fullName ?? `${input.firstName ?? ""} ${input.lastName ?? ""}`.trim();
+		const now = /* @__PURE__ */ new Date();
+		const computedFullName = input.fullName ?? ([input.firstName, input.lastName].filter(Boolean).join(" ").trim() || input.email || input.phone);
 		const draft = {
-			id: this.ids.next(),
-			fullName: fullName || input.email || input.phone || "Unknown",
-			status: "new",
+			...input,
+			fullName: computedFullName,
+			status: input.status ?? "new",
+			score: 0,
 			statusHistory: [{
-				status: "new",
+				status: input.status ?? "new",
 				occurredAt: now
-			}],
-			...input.firstName !== void 0 ? { firstName: input.firstName } : {},
-			...input.lastName !== void 0 ? { lastName: input.lastName } : {},
-			...input.email !== void 0 ? { email: input.email } : {},
-			...input.phone !== void 0 ? { phone: input.phone } : {},
-			...input.companyName !== void 0 ? { companyName: input.companyName } : {},
-			...input.jobTitle !== void 0 ? { jobTitle: input.jobTitle } : {},
-			...input.source !== void 0 ? { source: input.source } : {},
-			...input.campaignRef !== void 0 ? { campaignRef: input.campaignRef } : {},
-			...input.ownerId !== void 0 ? { ownerId: input.ownerId } : {},
-			...input.tags !== void 0 ? { tags: input.tags } : {},
-			...input.metadata !== void 0 ? { metadata: input.metadata } : {}
+			}]
 		};
-		const lead = await this.repo.create(draft);
-		const scored = await this._updateScore(lead, options);
-		await this._emit(CRM_EVENTS.LEAD_CREATED, {
-			leadId: scored.id,
-			email: scored.email,
-			score: scored.score
-		}, {
-			resource: "lead",
-			resourceId: scored.id
-		}, options);
-		return scored;
+		const created = await this.create(draft, ctx);
+		const score = this.scorer(created);
+		let result = created;
+		if (score !== 0) {
+			result = await this.update(String(created._id), { score }, ctx) ?? created;
+			await this.events.publish(createEvent(CRM_EVENTS.LEAD_SCORED, {
+				leadId: String(created._id),
+				score
+			}, ctx));
+		}
+		await this.events.publish(createEvent(CRM_EVENTS.LEAD_CREATED, {
+			leadId: String(result._id),
+			email: result.email,
+			score: result.score
+		}, ctx));
+		return result;
 	}
-	async markContacted(id, by, note, options = {}) {
-		return this._transition(id, "contacted", {
-			...by !== void 0 ? { by } : {},
-			...note !== void 0 ? { note } : {}
-		}, options);
+	async markContacted(id, extras = {}, ctx) {
+		return this._transition(id, "contacted", extras, ctx);
 	}
-	async qualify(id, by, note, options = {}) {
-		return this._transition(id, "qualified", {
-			...by !== void 0 ? { by } : {},
-			...note !== void 0 ? { note } : {}
-		}, options);
+	async qualify(id, extras = {}, ctx) {
+		return this._transition(id, "qualified", extras, ctx);
 	}
-	async disqualify(id, reason, by, options = {}) {
+	async disqualify(id, reason, extras = {}, ctx) {
 		const updated = await this._transition(id, "disqualified", {
+			...extras,
 			note: reason,
-			patch: { disqualifyReason: reason },
-			...by !== void 0 ? { by } : {}
-		}, options);
-		await this._emit(CRM_EVENTS.LEAD_DISQUALIFIED, {
+			patch: { disqualifyReason: reason }
+		}, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.LEAD_DISQUALIFIED, {
 			leadId: id,
 			reason
-		}, void 0, options);
+		}, ctx));
 		return updated;
 	}
-	async nurture(id, by, options = {}) {
-		return this._transition(id, "nurturing", { ...by !== void 0 ? { by } : {} }, options);
-	}
-	async convert(id, input, options = {}) {
-		const existing = await this._require(id);
-		if (existing.status === "converted") throw new LeadAlreadyConvertedError(id);
-		if (!canTransitionLead(existing.status, "converted")) throw new InvalidLeadTransitionError({
-			from: existing.status,
-			to: "converted",
-			leadId: id
-		});
-		let account;
-		let contact;
-		let opportunity;
-		try {
-			const innerOpts = {
-				emitEvents: false,
-				...options.session !== void 0 ? { session: options.session } : {}
-			};
-			if (existing.companyName) account = await this.accounts.create({
-				name: existing.companyName,
-				...existing.ownerId !== void 0 ? { ownerId: existing.ownerId } : {}
-			}, innerOpts);
-			const { given, family, preferred } = splitLeadName(existing);
-			contact = await this.contacts.create({
-				name: {
-					given,
-					family,
-					...preferred ? { preferred } : {}
-				},
-				contact: {
-					...existing.email !== void 0 ? { email: existing.email } : {},
-					...existing.phone !== void 0 ? { phone: existing.phone } : {}
-				},
-				...existing.jobTitle !== void 0 ? { jobTitle: existing.jobTitle } : {},
-				...account !== void 0 ? { accountId: account.id } : {},
-				...existing.ownerId !== void 0 ? { ownerId: existing.ownerId } : {}
-			}, innerOpts);
-			const opportunityName = input.opportunityName ?? `${existing.companyName ?? existing.fullName} — ${existing.source ?? "New"}`;
-			opportunity = await this.opportunities.create({
-				name: opportunityName,
-				pipelineId: input.pipelineId,
-				...account !== void 0 ? { accountId: account.id } : {},
-				primaryContactId: contact.id,
-				sourceLeadId: id,
-				...input.amount !== void 0 ? { amount: input.amount } : {},
-				...input.expectedCloseAt !== void 0 ? { expectedCloseAt: input.expectedCloseAt } : {},
-				...existing.ownerId !== void 0 ? { ownerId: existing.ownerId } : {}
-			}, innerOpts);
-			const convertedAt = this.clock.now();
-			const lead = await this._transition(id, "converted", {
-				patch: {
-					convertedContactId: contact.id,
-					...account !== void 0 ? { convertedAccountId: account.id } : {},
-					convertedOpportunityId: opportunity.id,
-					convertedAt
-				},
-				...input.by !== void 0 ? { by: input.by } : {}
-			}, options);
-			if (account) await this._emit(CRM_EVENTS.ACCOUNT_CREATED, { accountId: account.id }, {
-				resource: "account",
-				resourceId: account.id
-			}, options);
-			await this._emit(CRM_EVENTS.CONTACT_CREATED, {
-				contactId: contact.id,
-				email: contact.contact.email
-			}, {
-				resource: "contact",
-				resourceId: contact.id
-			}, options);
-			await this._emit(CRM_EVENTS.OPPORTUNITY_CREATED, {
-				opportunityId: opportunity.id,
-				pipelineId: opportunity.pipelineId,
-				stageId: opportunity.stageId
-			}, {
-				resource: "opportunity",
-				resourceId: opportunity.id
-			}, options);
-			await this._emit(CRM_EVENTS.LEAD_CONVERTED, {
-				leadId: id,
-				contactId: contact.id,
-				accountId: account?.id,
-				opportunityId: opportunity.id
-			}, {
-				resource: "lead",
-				resourceId: id
-			}, options);
-			return {
-				lead,
-				contactId: contact.id,
-				...account !== void 0 ? { accountId: account.id } : {},
-				opportunityId: opportunity.id
-			};
-		} catch (error) {
-			if (opportunity?.id && this.opportunities.delete) await this.opportunities.delete(opportunity.id);
-			if (contact?.id && this.contacts.delete) await this.contacts.delete(contact.id);
-			if (account?.id && this.accounts.delete) await this.accounts.delete(account.id);
-			throw error;
-		}
-	}
-	/** Recompute score and persist. Hosts can call on update or on demand. */
-	async recomputeScore(id, options = {}) {
-		const lead = await this._require(id);
-		return this._updateScore(lead, options);
-	}
-	findById(id) {
-		return this.repo.findById(id);
+	async nurture(id, extras = {}, ctx) {
+		return this._transition(id, "nurturing", extras, ctx);
 	}
-	list(filter) {
-		return this.repo.list(filter);
-	}
-	async _updateScore(lead, options = {}) {
+	/**
+	* Recompute + persist the lead's score. Called from `createLead`
+	* automatically; hosts also call this after enrichment writes.
+	*/
+	async recomputeScore(id, ctx) {
+		const lead = await this.getById(id, ctx);
+		if (!lead) throw new NotFoundError("Lead", id);
 		const score = this.scorer(lead);
 		if (score === lead.score) return lead;
-		const updated = await this.repo.update(lead.id, { score });
-		await this._emit(CRM_EVENTS.LEAD_SCORED, {
-			leadId: lead.id,
+		const updated = await this.update(id, { score }, ctx);
+		if (!updated) throw new NotFoundError("Lead", id);
+		await this.events.publish(createEvent(CRM_EVENTS.LEAD_SCORED, {
+			leadId: id,
 			score
-		}, {
-			resource: "lead",
-			resourceId: lead.id
-		}, options);
+		}, ctx));
 		return updated;
 	}
-	async _require(id) {
-		const l = await this.repo.findById(id);
-		if (!l) throw new NotFoundError("lead", id);
-		return l;
-	}
-	async _transition(id, target, opts = {}, options = {}) {
-		const existing = await this._require(id);
-		if (!canTransitionLead(existing.status, target)) throw new InvalidLeadTransitionError({
-			from: existing.status,
-			to: target,
-			leadId: id
-		});
+	async _transition(id, target, extras, ctx) {
+		const existing = await this.getById(id, ctx);
+		if (!existing) throw new NotFoundError("Lead", id);
+		LEAD_MACHINE.assertTransition(id, existing.status, target);
 		const entry = {
 			status: target,
-			occurredAt: this.clock.now(),
-			...opts.by !== void 0 ? { by: opts.by } : {},
-			...opts.note !== void 0 ? { note: opts.note } : {}
+			occurredAt: /* @__PURE__ */ new Date(),
+			...extras.by !== void 0 ? { by: extras.by } : {},
+			...extras.note !== void 0 ? { note: extras.note } : {}
 		};
-		const patch = {
-			...opts.patch ?? {},
-			statusHistory: [...existing.statusHistory, entry]
-		};
-		const updated = await this.repo.casStatus(id, existing.status, target, patch);
+		const updated = await assertAndClaim(LEAD_MACHINE, this, id, {
+			from: existing.status,
+			to: target,
+			patch: {
+				...extras.patch ?? {},
+				statusHistory: [...existing.statusHistory ?? [], entry]
+			},
+			options: ctx
+		});
 		if (!updated) throw new InvalidLeadTransitionError({
-			from: (await this.repo.findById(id))?.status ?? existing.status,
+			from: (await this.getById(id, ctx))?.status ?? existing.status,
 			to: target,
 			leadId: id
 		});
-		await this._emit(CRM_EVENTS.LEAD_STATUS_CHANGED, {
+		await this.events.publish(createEvent(CRM_EVENTS.LEAD_STATUS_CHANGED, {
 			leadId: id,
 			from: existing.status,
 			to: target
-		}, {
-			resource: "lead",
-			resourceId: id
-		}, options);
+		}, ctx));
 		return updated;
 	}
-	async _emit(event, payload, meta, options = {}) {
-		await emitCrmEvent(this.events, this.outbox, event, payload, meta, options.session);
-	}
-};
-//#endregion
-//#region src/domain/enums/opportunity-status.ts
-/**
-* Top-level opportunity status. Movement through pipeline STAGES
-* happens while status is `open`; `won` / `lost` are terminal
-* outcomes. Re-opening a lost deal is a host-level decision —
-* convention is to clone the opportunity rather than revive the
-* terminal record.
-*/
-const OPPORTUNITY_STATUSES = [
-	"open",
-	"won",
-	"lost",
-	"abandoned"
-];
-const OPPORTUNITY_TRANSITIONS = {
-	open: [
-		"won",
-		"lost",
-		"abandoned"
-	],
-	won: [],
-	lost: [],
-	abandoned: []
 };
-function canTransitionOpportunity(from, to) {
-	return OPPORTUNITY_TRANSITIONS[from].includes(to);
-}
 //#endregion
-//#region src/services/opportunity.service.ts
-/**
-* Opportunity lifecycle — stage movement + outcome resolution. Stage
-* changes call the pipeline service to validate membership + default
-* probability; status transitions (`won` / `lost` / `abandoned`) are
-* terminal.
-*/
-var OpportunityService = class {
-	repo;
-	pipelines;
+//#region src/repositories/opportunity.repository.ts
+var OpportunityRepository = class extends Repository {
 	events;
-	outbox;
-	clock;
-	ids;
-	constructor(config) {
-		this.repo = config.repo;
-		this.pipelines = config.pipelines;
-		this.events = config.events;
-		this.outbox = config.outbox;
-		this.clock = config.clock ?? systemClock;
-		this.ids = config.ids ?? cryptoIdGenerator;
-	}
-	async create(input, options = {}) {
-		const pipeline = await this.pipelines.findById(input.pipelineId);
-		if (!pipeline) throw new NotFoundError("pipeline", input.pipelineId);
-		if (pipeline.stages.length === 0) throw new EmptyPipelineError(pipeline.id);
-		const stage = input.stageId ? await this.pipelines.getStage(pipeline.id, input.stageId) : await this.pipelines.getFirstStage(pipeline.id);
-		const probability = input.probability ?? stage.defaultProbability;
-		const now = this.clock.now();
-		const opportunity = await this.repo.create({
-			id: this.ids.next(),
+	pipelines;
+	constructor(model, plugins, deps, pagination) {
+		super(model, plugins, pagination);
+		this.events = deps.events;
+		this.pipelines = deps.pipelines;
+	}
+	async openOpportunity(input, ctx) {
+		const stage = input.stageId ? await this.pipelines.getStage(input.pipelineId, input.stageId, ctx) : await this.pipelines.getFirstStage(input.pipelineId, ctx);
+		const now = /* @__PURE__ */ new Date();
+		const draft = {
 			name: input.name,
-			pipelineId: pipeline.id,
-			stageId: stage.id,
+			pipelineId: input.pipelineId,
+			stageId: String(stage._id),
 			status: "open",
+			probability: input.probability ?? stage.defaultProbability,
+			currency: input.currency ?? "USD",
 			statusHistory: [{
 				status: "open",
-				stageId: stage.id,
+				stageId: String(stage._id),
 				occurredAt: now
 			}],
-			probability,
 			...input.accountId !== void 0 ? { accountId: input.accountId } : {},
 			...input.primaryContactId !== void 0 ? { primaryContactId: input.primaryContactId } : {},
 			...input.sourceLeadId !== void 0 ? { sourceLeadId: input.sourceLeadId } : {},
 			...input.amount !== void 0 ? { amount: input.amount } : {},
 			...input.expectedCloseAt !== void 0 ? { expectedCloseAt: input.expectedCloseAt } : {},
 			...input.ownerId !== void 0 ? { ownerId: input.ownerId } : {},
-			...input.tags !== void 0 ? { tags: input.tags } : {},
+			...input.tags !== void 0 ? { tags: [...input.tags] } : {},
 			...input.metadata !== void 0 ? { metadata: input.metadata } : {}
-		});
-		if (options.emitEvents !== false) await this._emit(CRM_EVENTS.OPPORTUNITY_CREATED, {
-			opportunityId: opportunity.id,
-			pipelineId: pipeline.id,
-			stageId: stage.id
-		}, {
-			resource: "opportunity",
-			resourceId: opportunity.id
-		}, options);
-		return opportunity;
-	}
-	async moveToStage(id, input, options = {}) {
-		const existing = await this._require(id);
+		};
+		const created = await this.create(draft, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.OPPORTUNITY_CREATED, {
+			opportunityId: String(created._id),
+			pipelineId: input.pipelineId,
+			stageId: String(stage._id)
+		}, ctx));
+		return created;
+	}
+	/**
+	* Atomic stage move. CAS on `(status='open', stageId=current)` so two
+	* concurrent moves can't both win. Emits `stage_advanced` or
+	* `stage_regressed` based on `sequence` ordering of the embedded stages.
+	*/
+	async moveToStage(id, input, ctx) {
+		const existing = await this.getById(id, ctx);
+		if (!existing) throw new NotFoundError("Opportunity", id);
 		if (existing.status !== "open") throw new InvalidOpportunityTransitionError({
 			from: existing.status,
 			to: existing.status,
 			opportunityId: id
 		});
-		const target = await this.pipelines.getStage(existing.pipelineId, input.stageId);
-		const currentStage = await this.pipelines.getStage(existing.pipelineId, existing.stageId);
+		const target = await this.pipelines.getStage(String(existing.pipelineId), input.stageId, ctx);
+		const current = await this.pipelines.getStage(String(existing.pipelineId), existing.stageId, ctx);
 		const probability = input.probability ?? target.defaultProbability;
-		const now = this.clock.now();
 		const entry = {
 			status: "open",
-			stageId: target.id,
-			occurredAt: now,
+			stageId: String(target._id),
+			occurredAt: /* @__PURE__ */ new Date(),
 			...input.by !== void 0 ? { by: input.by } : {},
 			...input.note !== void 0 ? { note: input.note } : {}
 		};
-		const patch = {
+		const updated = await this.claim(id, {
+			field: "stageId",
+			from: existing.stageId,
+			to: String(target._id),
+			where: { status: "open" }
+		}, {
 			probability,
-			statusHistory: [...existing.statusHistory, entry]
-		};
-		const updated = await this.repo.casStage(id, existing.stageId, target.id, patch);
+			statusHistory: [...existing.statusHistory ?? [], entry]
+		}, ctx);
 		if (!updated) throw new StageNotInPipelineError({
-			pipelineId: existing.pipelineId,
-			stageId: target.id
+			pipelineId: String(existing.pipelineId),
+			stageId: String(target._id)
 		});
-		const eventName = target.sequence > currentStage.sequence ? CRM_EVENTS.OPPORTUNITY_STAGE_ADVANCED : CRM_EVENTS.OPPORTUNITY_STAGE_REGRESSED;
-		await this._emit(eventName, {
+		const event = target.sequence > current.sequence ? CRM_EVENTS.OPPORTUNITY_STAGE_ADVANCED : CRM_EVENTS.OPPORTUNITY_STAGE_REGRESSED;
+		await this.events.publish(createEvent(event, {
 			opportunityId: id,
 			from: {
-				stageId: currentStage.id,
-				sequence: currentStage.sequence
+				stageId: String(current._id),
+				sequence: current.sequence
 			},
 			to: {
-				stageId: target.id,
+				stageId: String(target._id),
 				sequence: target.sequence
 			}
-		}, {
-			resource: "opportunity",
-			resourceId: id
-		}, options);
+		}, ctx));
 		return updated;
 	}
-	async win(id, input = {}, options = {}) {
-		const patch = {
-			closedAt: input.closedAt ?? this.clock.now(),
+	async win(id, input = {}, ctx) {
+		const updated = await this._closeStatus(id, "won", {
+			closedAt: input.closedAt ?? /* @__PURE__ */ new Date(),
 			probability: 1,
 			...input.amount !== void 0 ? { amount: input.amount } : {}
-		};
-		const updated = await this._transitionStatus(id, "won", patch, input.by, input.note);
-		await this._emit(CRM_EVENTS.OPPORTUNITY_WON, {
+		}, {
+			...input.by !== void 0 ? { by: input.by } : {},
+			...input.note !== void 0 ? { note: input.note } : {}
+		}, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.OPPORTUNITY_WON, {
 			opportunityId: id,
 			amount: updated.amount
-		}, {
-			resource: "opportunity",
-			resourceId: id
-		}, options);
+		}, ctx));
 		return updated;
 	}
-	async lose(id, input = {}, options = {}) {
-		const patch = {
-			closedAt: input.closedAt ?? this.clock.now(),
+	async lose(id, input = {}, ctx) {
+		const updated = await this._closeStatus(id, "lost", {
+			closedAt: input.closedAt ?? /* @__PURE__ */ new Date(),
 			probability: 0,
 			...input.lostReasonId !== void 0 ? { lostReasonId: input.lostReasonId } : {}
-		};
-		const updated = await this._transitionStatus(id, "lost", patch, input.by, input.note);
-		await this._emit(CRM_EVENTS.OPPORTUNITY_LOST, {
-			opportunityId: id,
-			lostReasonId: input.lostReasonId
 		}, {
-			resource: "opportunity",
-			resourceId: id
-		}, options);
+			...input.by !== void 0 ? { by: input.by } : {},
+			...input.note !== void 0 ? { note: input.note } : {}
+		}, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.OPPORTUNITY_LOST, {
+			opportunityId: id,
+			lostReasonId: updated.lostReasonId
+		}, ctx));
 		return updated;
 	}
-	async abandon(id, by, note, options = {}) {
-		const patch = {
-			closedAt: this.clock.now(),
+	async abandon(id, by, note, ctx) {
+		const updated = await this._closeStatus(id, "abandoned", {
+			closedAt: /* @__PURE__ */ new Date(),
 			probability: 0
+		}, {
+			...by !== void 0 ? { by } : {},
+			...note !== void 0 ? { note } : {}
+		}, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.OPPORTUNITY_ABANDONED, { opportunityId: id }, ctx));
+		return updated;
+	}
+	async _closeStatus(id, target, patch, extras, ctx) {
+		const existing = await this.getById(id, ctx);
+		if (!existing) throw new NotFoundError("Opportunity", id);
+		OPPORTUNITY_MACHINE.assertTransition(id, existing.status, target);
+		const entry = {
+			status: target,
+			stageId: existing.stageId,
+			occurredAt: /* @__PURE__ */ new Date(),
+			...extras.by !== void 0 ? { by: extras.by } : {},
+			...extras.note !== void 0 ? { note: extras.note } : {}
+		};
+		const updated = await assertAndClaim(OPPORTUNITY_MACHINE, this, id, {
+			from: existing.status,
+			to: target,
+			patch: {
+				...patch,
+				statusHistory: [...existing.statusHistory ?? [], entry]
+			},
+			options: ctx
+		});
+		if (!updated) throw new InvalidOpportunityTransitionError({
+			from: (await this.getById(id, ctx))?.status ?? existing.status,
+			to: target,
+			opportunityId: id
+		});
+		return updated;
+	}
+};
+//#endregion
+//#region src/repositories/contact.repository.ts
+var ContactRepository = class extends Repository {
+	events;
+	constructor(model, plugins, deps, pagination) {
+		super(model, plugins, pagination);
+		this.events = deps.events;
+	}
+	/**
+	* Create + emit `crm:contact.created`. Hosts call this instead of
+	* `create()` when they want the event side-effect (e.g. webhook fan-out).
+	*/
+	async createContact(input, ctx) {
+		const created = await this.create(input, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.CONTACT_CREATED, {
+			contactId: String(created._id),
+			email: created.contact?.email
+		}, ctx));
+		return created;
+	}
+};
+//#endregion
+//#region src/repositories/account.repository.ts
+var AccountRepository = class extends Repository {
+	events;
+	constructor(model, plugins, deps, pagination) {
+		super(model, plugins, pagination);
+		this.events = deps.events;
+	}
+	async createAccount(input, ctx) {
+		const created = await this.create(input, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.ACCOUNT_CREATED, {
+			accountId: String(created._id),
+			name: created.name
+		}, ctx));
+		return created;
+	}
+};
+//#endregion
+//#region src/repositories/campaign.repository.ts
+var CampaignRepository = class extends Repository {
+	events;
+	rejectDuplicates;
+	constructor(model, plugins, deps, pagination) {
+		super(model, plugins, pagination);
+		this.events = deps.events;
+		this.rejectDuplicates = deps.rejectDuplicates ?? true;
+	}
+	async createCampaign(input, ctx) {
+		if (this.rejectDuplicates && input.name) {
+			if (await this.getOne({ name: input.name }, ctx)) throw new DuplicateCampaignError(input.name);
+		}
+		const now = /* @__PURE__ */ new Date();
+		const draft = {
+			...input,
+			status: input.status ?? "draft",
+			currency: input.currency ?? "USD",
+			statusHistory: [{
+				status: input.status ?? "draft",
+				occurredAt: now
+			}]
+		};
+		const created = await this.create(draft, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.CAMPAIGN_CREATED, {
+			campaignId: String(created._id),
+			name: created.name
+		}, ctx));
+		return created;
+	}
+	async activate(id, by, ctx) {
+		const updated = await this._transition(id, "active", { ...by !== void 0 ? { by } : {} }, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.CAMPAIGN_ACTIVATED, { campaignId: id }, ctx));
+		return updated;
+	}
+	async pause(id, reason, by, ctx) {
+		const updated = await this._transition(id, "paused", {
+			...by !== void 0 ? { by } : {},
+			...reason !== void 0 ? { note: reason } : {}
+		}, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.CAMPAIGN_PAUSED, {
+			campaignId: id,
+			reason
+		}, ctx));
+		return updated;
+	}
+	async resume(id, by, ctx) {
+		const updated = await this._transition(id, "active", { ...by !== void 0 ? { by } : {} }, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.CAMPAIGN_RESUMED, { campaignId: id }, ctx));
+		return updated;
+	}
+	async complete(id, extras = {}, ctx) {
+		const patch = extras.actualRevenueAmount !== void 0 ? { actualRevenueAmount: extras.actualRevenueAmount } : {};
+		const updated = await this._transition(id, "completed", extras, ctx, patch);
+		await this.events.publish(createEvent(CRM_EVENTS.CAMPAIGN_COMPLETED, {
+			campaignId: id,
+			actualRevenueAmount: updated.actualRevenueAmount
+		}, ctx));
+		return updated;
+	}
+	async archive(id, by, ctx) {
+		const updated = await this._transition(id, "archived", { ...by !== void 0 ? { by } : {} }, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.CAMPAIGN_ARCHIVED, { campaignId: id }, ctx));
+		return updated;
+	}
+	async _transition(id, target, extras, ctx, patch = {}) {
+		const existing = await this.getById(id, ctx);
+		if (!existing) throw new NotFoundError("Campaign", id);
+		CAMPAIGN_MACHINE.assertTransition(id, existing.status, target);
+		const entry = {
+			status: target,
+			occurredAt: /* @__PURE__ */ new Date(),
+			...extras.by !== void 0 ? { by: extras.by } : {},
+			...extras.note !== void 0 ? { note: extras.note } : {}
+		};
+		const updated = await assertAndClaim(CAMPAIGN_MACHINE, this, id, {
+			from: existing.status,
+			to: target,
+			patch: {
+				...patch,
+				statusHistory: [...existing.statusHistory ?? [], entry]
+			},
+			options: ctx
+		});
+		if (!updated) throw new InvalidCampaignTransitionError({
+			from: (await this.getById(id, ctx))?.status ?? existing.status,
+			to: target,
+			campaignId: id
+		});
+		return updated;
+	}
+};
+//#endregion
+//#region src/repositories/subscription.repository.ts
+/**
+* SubscriptionRepository — extends mongokit Repository.
+*
+* Double opt-in flow:
+*   subscribe()    → status `pending` (or `confirmed` when DOI off)
+*   confirm(token) → `pending → confirmed`
+*   unsubscribe()  → terminal `unsubscribed`
+*   markBounced()  → terminal `bounced`
+*   markComplained() → terminal `complained`
+*
+* Token lookups (confirm, unsubscribe) use `getOne({ token })` — no
+* proxy `findByConfirmationToken` (Rule §3).
+*/
+var SubscriptionRepository = class extends Repository {
+	events;
+	defaultRequireDoubleOptIn;
+	constructor(model, plugins, deps, pagination) {
+		super(model, plugins, pagination);
+		this.events = deps.events;
+		this.defaultRequireDoubleOptIn = deps.defaultRequireDoubleOptIn ?? true;
+	}
+	async subscribe(input, ctx) {
+		if (await this.getOne({
+			contactId: input.contactId,
+			campaignId: input.campaignId,
+			status: { $in: ["pending", "confirmed"] }
+		}, ctx)) throw new DuplicateSubscriptionError({
+			contactId: input.contactId,
+			campaignId: input.campaignId
+		});
+		const doubleOptIn = input.requireDoubleOptIn ?? this.defaultRequireDoubleOptIn;
+		const now = /* @__PURE__ */ new Date();
+		const status = doubleOptIn ? "pending" : "confirmed";
+		const draft = {
+			contactId: input.contactId,
+			campaignId: input.campaignId,
+			status,
+			statusHistory: [{
+				status,
+				occurredAt: now
+			}],
+			consentTimestamp: now,
+			unsubscribeToken: randomUUID(),
+			...doubleOptIn ? { confirmationToken: randomUUID() } : { confirmedAt: now },
+			...input.source !== void 0 ? { source: input.source } : {},
+			...input.consentIpAddress !== void 0 ? { consentIpAddress: input.consentIpAddress } : {},
+			...input.consentUserAgent !== void 0 ? { consentUserAgent: input.consentUserAgent } : {},
+			...input.metadata !== void 0 ? { metadata: input.metadata } : {}
+		};
+		const sub = await this.create(draft, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.SUBSCRIPTION_CREATED, {
+			subscriptionId: String(sub._id),
+			contactId: sub.contactId,
+			campaignId: sub.campaignId,
+			requiresConfirmation: doubleOptIn
+		}, ctx));
+		return sub;
+	}
+	async confirm(token, ctx) {
+		const sub = await this.getOne({ confirmationToken: token }, ctx);
+		if (!sub || sub.status !== "pending") throw new InvalidConfirmationTokenError();
+		const confirmedAt = /* @__PURE__ */ new Date();
+		const updated = await this._transition(String(sub._id), "confirmed", { patch: { confirmedAt } }, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.SUBSCRIPTION_CONFIRMED, {
+			subscriptionId: String(sub._id),
+			contactId: sub.contactId,
+			campaignId: sub.campaignId,
+			confirmedAt: confirmedAt.toISOString()
+		}, ctx));
+		return updated;
+	}
+	async unsubscribe(token, reason, ctx) {
+		const sub = await this.getOne({ unsubscribeToken: token }, ctx);
+		if (!sub) throw new InvalidUnsubscribeTokenError();
+		if (sub.status === "unsubscribed") return sub;
+		const unsubscribedAt = /* @__PURE__ */ new Date();
+		const updated = await this._transition(String(sub._id), "unsubscribed", {
+			...reason !== void 0 ? { note: reason } : {},
+			patch: {
+				unsubscribedAt,
+				...reason !== void 0 ? { unsubscribeReason: reason } : {}
+			}
+		}, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.SUBSCRIPTION_UNSUBSCRIBED, {
+			subscriptionId: String(sub._id),
+			contactId: sub.contactId,
+			campaignId: sub.campaignId,
+			...reason !== void 0 ? { reason } : {}
+		}, ctx));
+		return updated;
+	}
+	async markBounced(id, reason, ctx) {
+		const existing = await this.getById(id, ctx);
+		if (!existing) throw new NotFoundError("Subscription", id);
+		if (existing.status === "bounced") return existing;
+		const bouncedAt = /* @__PURE__ */ new Date();
+		const updated = await this._transition(id, "bounced", {
+			...reason !== void 0 ? { note: reason } : {},
+			patch: {
+				bouncedAt,
+				...reason !== void 0 ? { bounceReason: reason } : {}
+			}
+		}, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.SUBSCRIPTION_BOUNCED, {
+			subscriptionId: id,
+			contactId: existing.contactId,
+			campaignId: existing.campaignId,
+			...reason !== void 0 ? { reason } : {}
+		}, ctx));
+		return updated;
+	}
+	async markComplained(id, ctx) {
+		const existing = await this.getById(id, ctx);
+		if (!existing) throw new NotFoundError("Subscription", id);
+		if (existing.status === "complained") return existing;
+		const complainedAt = /* @__PURE__ */ new Date();
+		const updated = await this._transition(id, "complained", { patch: { complainedAt } }, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.SUBSCRIPTION_COMPLAINED, {
+			subscriptionId: id,
+			contactId: existing.contactId,
+			campaignId: existing.campaignId
+		}, ctx));
+		return updated;
+	}
+	async _transition(id, target, opts, ctx) {
+		const existing = await this.getById(id, ctx);
+		if (!existing) throw new NotFoundError("Subscription", id);
+		SUBSCRIPTION_MACHINE.assertTransition(id, existing.status, target);
+		const entry = {
+			status: target,
+			occurredAt: /* @__PURE__ */ new Date(),
+			...opts.by !== void 0 ? { by: opts.by } : {},
+			...opts.note !== void 0 ? { note: opts.note } : {}
+		};
+		const updated = await assertAndClaim(SUBSCRIPTION_MACHINE, this, id, {
+			from: existing.status,
+			to: target,
+			patch: {
+				...opts.patch ?? {},
+				statusHistory: [...existing.statusHistory ?? [], entry]
+			},
+			options: ctx
+		});
+		if (!updated) throw new InvalidSubscriptionTransitionError({
+			from: (await this.getById(id, ctx))?.status ?? existing.status,
+			to: target,
+			subscriptionId: id
+		});
+		return updated;
+	}
+};
+//#endregion
+//#region src/repositories/activity.repository.ts
+var ActivityRepository = class extends Repository {
+	events;
+	constructor(model, plugins, deps, pagination) {
+		super(model, plugins, pagination);
+		this.events = deps.events;
+	}
+	async plan(input, ctx) {
+		const draft = {
+			...input,
+			status: "planned"
 		};
-		const updated = await this._transitionStatus(id, "abandoned", patch, by, note);
-		await this._emit(CRM_EVENTS.OPPORTUNITY_ABANDONED, { opportunityId: id }, {
-			resource: "opportunity",
-			resourceId: id
-		}, options);
+		const created = await this.create(draft, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.ACTIVITY_PLANNED, {
+			activityId: String(created._id),
+			type: created.type,
+			subjectKind: created.subjectKind,
+			subjectId: String(created.subjectId)
+		}, ctx));
+		return created;
+	}
+	async start(id, ctx) {
+		return this._transition(id, "in_progress", {}, ctx);
+	}
+	async complete(id, completedAt, ctx) {
+		const ts = completedAt ?? /* @__PURE__ */ new Date();
+		const updated = await this._transition(id, "completed", { completedAt: ts }, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.ACTIVITY_COMPLETED, {
+			activityId: id,
+			completedAt: ts.toISOString()
+		}, ctx));
+		return updated;
+	}
+	async cancel(id, reason, ctx) {
+		const updated = await this._transition(id, "cancelled", reason ? { metadata: { cancelReason: reason } } : {}, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.ACTIVITY_CANCELLED, {
+			activityId: id,
+			...reason !== void 0 ? { reason } : {}
+		}, ctx));
+		return updated;
+	}
+	async _transition(id, target, patch, ctx) {
+		const existing = await this.getById(id, ctx);
+		if (!existing) throw new NotFoundError("Activity", id);
+		ACTIVITY_MACHINE.assertTransition(id, existing.status, target);
+		const updated = await assertAndClaim(ACTIVITY_MACHINE, this, id, {
+			from: existing.status,
+			to: target,
+			patch,
+			options: ctx
+		});
+		if (!updated) throw new InvalidActivityTransitionError({
+			from: (await this.getById(id, ctx))?.status ?? existing.status,
+			to: target,
+			activityId: id
+		});
+		return updated;
+	}
+};
+//#endregion
+//#region src/repositories/note.repository.ts
+var NoteRepository = class extends Repository {
+	events;
+	constructor(model, plugins, deps, pagination) {
+		super(model, plugins, pagination);
+		this.events = deps.events;
+	}
+	async addNote(input, ctx) {
+		const created = await this.create(input, ctx);
+		await this.events.publish(createEvent(CRM_EVENTS.NOTE_ADDED, {
+			noteId: String(created._id),
+			subjectKind: created.subjectKind,
+			subjectId: String(created.subjectId)
+		}, ctx));
+		return created;
+	}
+};
+//#endregion
+//#region src/repositories/loss-reason.repository.ts
+var LossReasonRepository = class extends Repository {
+	events;
+	constructor(model, plugins, deps, pagination) {
+		super(model, plugins, pagination);
+		this.events = deps.events;
+	}
+	/** Hide from pickers without breaking historical FKs. */
+	async archive(id, ctx) {
+		const updated = await this.update(id, { isActive: false }, ctx);
+		if (!updated) throw new NotFoundError("LossReason", id);
 		return updated;
 	}
-	async delete(id) {
-		await this._require(id);
-		await this.repo.delete(id);
+};
+//#endregion
+//#region src/repositories/email-event.repository.ts
+const KIND_TO_EVENT = {
+	open: CRM_EVENTS.EMAIL_EVENT_OPENED,
+	click: CRM_EVENTS.EMAIL_EVENT_CLICKED,
+	bounce: CRM_EVENTS.EMAIL_EVENT_BOUNCED,
+	complaint: CRM_EVENTS.EMAIL_EVENT_COMPLAINED,
+	unsubscribe: CRM_EVENTS.EMAIL_EVENT_UNSUBSCRIBED
+};
+var EmailEventRepository = class extends Repository {
+	events;
+	constructor(model, plugins, deps, pagination) {
+		super(model, plugins, pagination);
+		this.events = deps.events;
+	}
+	async recordOpen(input, ctx) {
+		return this._record("open", input, ctx);
+	}
+	async recordClick(input, ctx) {
+		return this._record("click", input, ctx);
+	}
+	async recordBounce(input, ctx) {
+		return this._record("bounce", input, ctx);
+	}
+	async recordComplaint(input, ctx) {
+		return this._record("complaint", input, ctx);
 	}
-	findById(id) {
-		return this.repo.findById(id);
+	async recordUnsubscribe(input, ctx) {
+		return this._record("unsubscribe", input, ctx);
+	}
+	async _record(kind, input, ctx) {
+		const draft = {
+			kind,
+			subjectKind: input.subjectKind,
+			subjectId: input.subjectId,
+			...input.campaignId !== void 0 ? { campaignId: input.campaignId } : {},
+			...input.messageId !== void 0 ? { messageId: input.messageId } : {},
+			...input.url !== void 0 ? { url: input.url } : {},
+			...input.userAgent !== void 0 ? { userAgent: input.userAgent } : {},
+			...input.ip !== void 0 ? { ip: input.ip } : {},
+			...input.metadata !== void 0 ? { metadata: input.metadata } : {}
+		};
+		const created = await this.create(draft, ctx);
+		await this.events.publish(createEvent(KIND_TO_EVENT[kind], {
+			eventId: String(created._id),
+			kind,
+			subjectKind: input.subjectKind,
+			subjectId: input.subjectId,
+			campaignId: input.campaignId
+		}, ctx));
+		return created;
 	}
-	list(filter) {
-		return this.repo.list(filter);
+};
+//#endregion
+//#region src/repositories/create-repositories.ts
+/**
+* Repository factory — composes the shared mongokit plugin stack and
+* constructs every CRM repository on the host's models.
+*
+* Plugins applied (in order, per PACKAGE_RULES §9 / §22):
+*   1. methodRegistryPlugin  — required wiring for other plugins
+*   2. multiTenantPlugin     — when `multiTenant !== false`
+*   3. aggregateHelpersPlugin
+*   4. host-supplied `plugins[]` — appended last so hosts can override
+*/
+function createCrmRepositories(models, deps) {
+	const { events, config } = deps;
+	const pagination = config.pagination;
+	const plugins = [methodRegistryPlugin()];
+	if (config.multiTenant) plugins.push(multiTenantPlugin({
+		tenantField: "organizationId",
+		contextKey: "organizationId",
+		required: true,
+		fieldType: config.tenantFieldType
+	}));
+	plugins.push(aggregateHelpersPlugin());
+	if (config.plugins.length > 0) plugins.push(...config.plugins);
+	const pipeline = new PipelineRepository(models.Pipeline, plugins, { events }, pagination);
+	const lead = new LeadRepository(models.Lead, plugins, { events }, pagination);
+	const opportunity = new OpportunityRepository(models.Opportunity, plugins, {
+		events,
+		pipelines: pipeline
+	}, pagination);
+	const contact = new ContactRepository(models.Contact, plugins, { events }, pagination);
+	const account = new AccountRepository(models.Account, plugins, { events }, pagination);
+	const campaign = new CampaignRepository(models.Campaign, plugins, { events }, pagination);
+	const subscription = new SubscriptionRepository(models.Subscription, plugins, { events }, pagination);
+	const activity = new ActivityRepository(models.Activity, plugins, { events }, pagination);
+	const note = new NoteRepository(models.Note, plugins, { events }, pagination);
+	const lossReason = new LossReasonRepository(models.LossReason, plugins, { events }, pagination);
+	const emailEvent = new EmailEventRepository(models.EmailEvent, plugins, { events }, pagination);
+	return Object.freeze({
+		pipeline,
+		lead,
+		opportunity,
+		contact,
+		account,
+		campaign,
+		subscription,
+		activity,
+		note,
+		lossReason,
+		emailEvent
+	});
+}
+//#endregion
+//#region src/events/in-process-bus.ts
+/**
+* In-process event bus — default fallback when no `eventTransport` is
+* provided to `createCrm`. Structurally identical to arc's
+* `MemoryEventTransport`; pattern matching is delegated to primitives.
+* Handler errors are swallowed — event emission never blocks writes.
+*/
+var InProcessCrmBus = class {
+	name = "in-process-crm";
+	subs = [];
+	logger;
+	constructor(options) {
+		if (options?.logger) this.logger = options.logger;
 	}
-	async _require(id) {
-		const o = await this.repo.findById(id);
-		if (!o) throw new NotFoundError("opportunity", id);
-		return o;
+	async publish(event) {
+		const matching = this.subs.filter((s) => matchEventPattern(s.pattern, event.type));
+		for (const sub of matching) try {
+			await sub.handler(event);
+		} catch (err) {
+			this.logger?.error?.(`[crm] event handler error [${event.type}]`, { error: err instanceof Error ? err.message : String(err) });
+		}
 	}
-	async _transitionStatus(id, target, patch, by, note) {
-		const existing = await this._require(id);
-		if (!canTransitionOpportunity(existing.status, target)) throw new InvalidOpportunityTransitionError({
-			from: existing.status,
-			to: target,
-			opportunityId: id
-		});
-		const now = this.clock.now();
-		const entry = {
-			status: target,
-			stageId: existing.stageId,
-			occurredAt: now,
-			...by !== void 0 ? { by } : {},
-			...note !== void 0 ? { note } : {}
+	async subscribe(pattern, handler) {
+		const sub = {
+			pattern,
+			handler
 		};
-		const fullPatch = {
-			...patch,
-			statusHistory: [...existing.statusHistory, entry]
+		this.subs.push(sub);
+		return () => {
+			this.subs = this.subs.filter((s) => s !== sub);
 		};
-		const updated = await this.repo.casStatus(id, existing.status, target, fullPatch);
-		if (!updated) throw new InvalidOpportunityTransitionError({
-			from: (await this.repo.findById(id))?.status ?? existing.status,
-			to: target,
-			opportunityId: id
-		});
-		return updated;
 	}
-	async _emit(event, payload, meta, options = {}) {
-		await emitCrmEvent(this.events, this.outbox, event, payload, meta, options.session);
+	async close() {
+		this.subs = [];
 	}
 };
 //#endregion
-//#region src/services/pipeline.service.ts
-/**
-* Pipeline lifecycle + stage helpers. The service owns stage id
-* generation so callers don't have to — create a pipeline with an
-* array of stage seeds and the service hands back the persisted
-* pipeline with ids assigned.
-*/
-var PipelineService = class {
-	repo;
+//#region src/engine/create-crm.ts
+async function createCrm(config) {
+	if (!config.connection) throw new Error("[crm] CrmConfig.connection is required");
+	const resolved = {
+		connection: config.connection,
+		tenantFieldType: config.tenantFieldType ?? "objectId",
+		multiTenant: config.multiTenant ?? true,
+		...config.logger !== void 0 ? { logger: config.logger } : {},
+		...config.pagination !== void 0 ? { pagination: config.pagination } : {},
+		plugins: config.plugins ?? []
+	};
+	const events = config.eventTransport ?? new InProcessCrmBus(config.logger ? { logger: config.logger } : void 0);
+	const models = createCrmModels(config.connection, resolved);
+	const repositories = createCrmRepositories(models, {
+		events,
+		config: resolved
+	});
+	return Object.freeze({
+		models,
+		repositories,
+		events,
+		config: Object.freeze(resolved),
+		async dispose() {
+			await events.close?.();
+		}
+	});
+}
+//#endregion
+//#region src/services/lead.service.ts
+var LeadService = class LeadService {
+	leads;
+	contacts;
+	accounts;
+	opportunities;
 	events;
-	outbox;
-	clock;
-	ids;
-	constructor(config) {
-		this.repo = config.repo;
-		this.events = config.events;
-		this.outbox = config.outbox;
-		this.clock = config.clock ?? systemClock;
-		this.ids = config.ids ?? cryptoIdGenerator;
-	}
-	async create(input, options = {}) {
-		if (input.stages.length === 0) throw new EmptyPipelineError("<new>");
-		const id = this.ids.next();
-		const stages = input.stages.map((s) => ({
-			id: this.ids.next(),
-			...s
-		}));
-		const pipeline = await this.repo.create({
-			id,
-			name: input.name,
-			isArchived: false,
-			stages,
-			...input.teamRef !== void 0 ? { teamRef: input.teamRef } : {},
-			...input.metadata !== void 0 ? { metadata: input.metadata } : {}
+	constructor(deps) {
+		this.leads = deps.lead;
+		this.contacts = deps.contact;
+		this.accounts = deps.account;
+		this.opportunities = deps.opportunity;
+		this.events = deps.events;
+	}
+	/**
+	* Construct from an already-built CrmEngine — the host's preferred path.
+	* Avoids manually wiring four repositories.
+	*/
+	static fromEngine(engine) {
+		return new LeadService({
+			lead: engine.repositories.lead,
+			contact: engine.repositories.contact,
+			account: engine.repositories.account,
+			opportunity: engine.repositories.opportunity,
+			events: engine.events
 		});
-		await this._emit(CRM_EVENTS.PIPELINE_CREATED, { pipelineId: pipeline.id }, {
-			resource: "pipeline",
-			resourceId: pipeline.id
-		}, options);
-		return pipeline;
-	}
-	async archive(id, options = {}) {
-		await this._require(id);
-		const updated = await this.repo.update(id, { isArchived: true });
-		await this._emit(CRM_EVENTS.PIPELINE_ARCHIVED, { pipelineId: id }, {
-			resource: "pipeline",
-			resourceId: id
-		}, options);
-		return updated;
 	}
-	async getStage(pipelineId, stageId) {
-		const stage = (await this._require(pipelineId)).stages.find((s) => s.id === stageId);
-		if (!stage) throw new StageNotInPipelineError({
-			pipelineId,
-			stageId
+	/**
+	* Convert a Lead into Account + Contact + Opportunity, then transition
+	* the lead. Wrap the call in `connection.transaction()` and pass the
+	* session via `ctx.session` for atomicity — all four writes commit or
+	* roll back together.
+	*
+	* Best-effort compensation: if a downstream write fails, already-
+	* created docs are deleted in reverse order. The reverse delete may
+	* itself fail (e.g. transient DB issues) — when transactions are
+	* active, prefer that path; compensation is the no-transaction
+	* fallback.
+	*/
+	async convert(leadId, input, ctx) {
+		const lead = await this.leads.getById(leadId, ctx);
+		if (!lead) throw new NotFoundError("Lead", leadId);
+		if (lead.status === "converted") throw new LeadAlreadyConvertedError(leadId);
+		if (!LEAD_MACHINE.canTransition(lead.status, "converted")) throw new InvalidLeadTransitionError({
+			from: lead.status,
+			to: "converted",
+			leadId
 		});
-		return stage;
-	}
-	/** First stage in the ordered pipeline (minimum `sequence`). */
-	async getFirstStage(pipelineId) {
-		const stages = [...(await this._require(pipelineId)).stages].sort((a, b) => a.sequence - b.sequence);
-		if (stages.length === 0) throw new EmptyPipelineError(pipelineId);
-		return stages[0];
+		let account;
+		let contact;
+		let opportunity;
+		try {
+			if (lead.companyName) account = await this.accounts.createAccount({
+				name: lead.companyName,
+				...lead.ownerId !== void 0 ? { ownerId: lead.ownerId } : {}
+			}, ctx);
+			const name = splitLeadName(lead);
+			const contactInfo = {
+				...lead.email !== void 0 ? { email: lead.email } : {},
+				...lead.phone !== void 0 ? { phone: lead.phone } : {}
+			};
+			contact = await this.contacts.createContact({
+				name,
+				contact: contactInfo,
+				...lead.jobTitle !== void 0 ? { jobTitle: lead.jobTitle } : {},
+				...account !== void 0 ? { accountId: String(account._id) } : {},
+				...lead.ownerId !== void 0 ? { ownerId: lead.ownerId } : {}
+			}, ctx);
+			const opportunityName = input.opportunityName ?? `${lead.companyName ?? lead.fullName} — ${lead.source ?? "New"}`;
+			opportunity = await this.opportunities.openOpportunity({
+				name: opportunityName,
+				pipelineId: input.pipelineId,
+				...account !== void 0 ? { accountId: String(account._id) } : {},
+				primaryContactId: String(contact._id),
+				sourceLeadId: leadId,
+				...input.amount !== void 0 ? { amount: input.amount } : {},
+				...input.currency !== void 0 ? { currency: input.currency } : {},
+				...input.expectedCloseAt !== void 0 ? { expectedCloseAt: input.expectedCloseAt } : {},
+				...lead.ownerId !== void 0 ? { ownerId: lead.ownerId } : {}
+			}, ctx);
+			const finalLead = await this.leads.qualify(leadId, {}, ctx).catch(() => null) ?? lead;
+			const converted = await this._markConverted(String(finalLead._id), finalLead.status, {
+				contactId: String(contact._id),
+				...account !== void 0 ? { accountId: String(account._id) } : {},
+				opportunityId: String(opportunity._id),
+				...input.by !== void 0 ? { by: input.by } : {}
+			}, ctx);
+			await this.events.publish(createEvent(CRM_EVENTS.LEAD_CONVERTED, {
+				leadId,
+				contactId: String(contact._id),
+				accountId: account ? String(account._id) : void 0,
+				opportunityId: String(opportunity._id)
+			}, ctx));
+			return {
+				lead: converted,
+				contact,
+				...account !== void 0 ? { account } : {},
+				opportunity,
+				contactId: String(contact._id),
+				...account !== void 0 ? { accountId: String(account._id) } : {},
+				opportunityId: String(opportunity._id)
+			};
+		} catch (err) {
+			if (!ctx?.session) try {
+				if (opportunity?._id) await this.opportunities.delete(String(opportunity._id), ctx);
+				if (contact?._id) await this.contacts.delete(String(contact._id), ctx);
+				if (account?._id) await this.accounts.delete(String(account._id), ctx);
+			} catch {}
+			throw err;
+		}
 	}
-	/** Next stage after `stageId` in the ordered pipeline, or `null` at the end. */
-	async getNextStage(pipelineId, stageId) {
-		const stages = [...(await this._require(pipelineId)).stages].sort((a, b) => a.sequence - b.sequence);
-		const idx = stages.findIndex((s) => s.id === stageId);
-		if (idx === -1) throw new StageNotInPipelineError({
-			pipelineId,
-			stageId
+	/**
+	* The state-machine hop from whichever status the lead is in to
+	* `converted`. We do this directly (instead of calling
+	* `LeadRepository.qualify` first then a hypothetical `complete`)
+	* because the conversion is "this lead is done" regardless of where
+	* it started — bypassing the `qualified` waypoint is intentional when
+	* a Lead is converted directly from `new` (importers, webhooks).
+	*/
+	async _markConverted(leadId, fromStatus, crossRefs, ctx) {
+		if (!LEAD_MACHINE.canTransition(fromStatus, "converted")) throw new InvalidLeadTransitionError({
+			from: fromStatus,
+			to: "converted",
+			leadId
 		});
-		return stages[idx + 1] ?? null;
-	}
-	findById(id) {
-		return this.repo.findById(id);
-	}
-	list(includeArchived) {
-		return this.repo.list(includeArchived);
-	}
-	async _require(id) {
-		const p = await this.repo.findById(id);
-		if (!p) throw new NotFoundError("pipeline", id);
-		return p;
-	}
-	async _emit(event, payload, meta, options = {}) {
-		await emitCrmEvent(this.events, this.outbox, event, payload, meta, options.session);
+		const patch = {
+			convertedContactId: crossRefs.contactId,
+			convertedOpportunityId: crossRefs.opportunityId,
+			convertedAt: /* @__PURE__ */ new Date(),
+			...crossRefs.accountId !== void 0 ? { convertedAccountId: crossRefs.accountId } : {}
+		};
+		const entry = {
+			status: "converted",
+			occurredAt: /* @__PURE__ */ new Date(),
+			...crossRefs.by !== void 0 ? { by: crossRefs.by } : {}
+		};
+		const current = await this.leads.getById(leadId, ctx);
+		const updated = await this.leads.claim(leadId, {
+			field: "status",
+			from: fromStatus,
+			to: "converted"
+		}, {
+			...patch,
+			statusHistory: [...current?.statusHistory ?? [], entry]
+		}, ctx);
+		if (!updated) throw new NotFoundError("Lead", leadId);
+		return updated;
 	}
 };
+/**
+* Derive a `PersonName` from a Lead's flat fields. Web forms capture
+* either split `firstName`/`lastName` or a single `fullName`.
+*/
+function splitLeadName(lead) {
+	if (lead.firstName || lead.lastName) {
+		const out = {
+			given: lead.firstName ?? "",
+			family: lead.lastName ?? ""
+		};
+		const combined = `${lead.firstName ?? ""} ${lead.lastName ?? ""}`.trim();
+		if (lead.fullName && lead.fullName !== combined) out.preferred = lead.fullName;
+		return out;
+	}
+	const parts = (lead.fullName ?? "").trim().split(/\s+/);
+	if (parts.length <= 1) return {
+		given: parts[0] ?? "Unknown",
+		family: ""
+	};
+	const family = parts.pop() ?? "";
+	return {
+		given: parts.join(" "),
+		family
+	};
+}
 //#endregion
-//#region src/services/forecast.ts
+//#region src/shared/calculators/forecast.ts
 /**
-* Aggregate opportunities into a forecast table — one row per
-* bucket (month by default). Committed is `Σ amount`; weighted is
-* `Σ amount × probability`.
-*
-* Integer-safe: sums are computed on minor-unit amounts (consistent
-* with `@classytic/primitives/money`'s integer convention). Currency
-* mismatch across a bucket throws — hosts dealing in multi-currency
-* run this once per currency after partitioning.
+* Aggregate opportunities into a forecast table — one row per bucket.
+* Currency mismatch within a bucket throws — partition by currency
+* upstream when multi-currency.
 */
 function forecast(opportunities, options = {}) {
 	const bucketFn = options.bucket ?? defaultBucket;
@@ -1145,11 +2573,11 @@ function forecast(opportunities, options = {}) {
 	const rows = /* @__PURE__ */ new Map();
 	for (const o of opportunities) {
 		if (!include(o)) continue;
-		const amt = o.amount.amount;
+		const amt = o.amount;
 		const bucket = bucketFn(o);
 		const existing = rows.get(bucket);
 		if (existing) {
-			if (existing.currency !== o.amount.currency) throw new Error(`Forecast bucket '${bucket}' mixes currencies (${existing.currency} + ${o.amount.currency}). Partition by currency before calling forecast().`);
+			if (existing.currency !== o.currency) throw new Error(`Forecast bucket '${bucket}' mixes currencies (${existing.currency} + ${o.currency}). Partition by currency before calling forecast().`);
 			rows.set(bucket, {
 				...existing,
 				committed: existing.committed + amt,
@@ -1161,18 +2589,22 @@ function forecast(opportunities, options = {}) {
 			committed: amt,
 			weighted: Math.round(amt * o.probability),
 			count: 1,
-			currency: o.amount.currency
+			currency: o.currency
 		});
 	}
 	return [...rows.values()].sort((a, b) => a.bucket.localeCompare(b.bucket));
 }
 function defaultInclude(o) {
-	return o.status === "open" && !!o.amount && !!o.expectedCloseAt;
+	return o.status === "open" && o.amount !== void 0 && !!o.expectedCloseAt;
 }
 function defaultBucket(o) {
 	const d = o.expectedCloseAt;
 	return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}`;
 }
+/**
+* "Where do deals die?" summary — opportunities partitioned across
+* stages with current count + won/lost-from-here.
+*/
 function pipelineConversion(opportunities, stageIds) {
 	return stageIds.map((stageId) => {
 		let currentCount = 0;
@@ -1181,7 +2613,7 @@ function pipelineConversion(opportunities, stageIds) {
 		for (const o of opportunities) {
 			if (o.stageId === stageId && o.status === "open") currentCount++;
 			if (o.status === "won" || o.status === "lost") {
-				if (o.statusHistory.some((h) => h.stageId === stageId) || o.stageId === stageId) if (o.status === "won") wonFromHere++;
+				if (o.statusHistory?.some((h) => h.stageId === stageId) || o.stageId === stageId) if (o.status === "won") wonFromHere++;
 				else lostFromHere++;
 			}
 		}
@@ -1196,748 +2628,345 @@ function pipelineConversion(opportunities, stageIds) {
 	});
 }
 //#endregion
-//#region src/adapters/in-memory/account-repository.ts
-var InMemoryAccountRepository = class {
-	items = /* @__PURE__ */ new Map();
-	constructor(clock = systemClock) {
-		this.clock = clock;
-	}
-	async findById(id) {
-		return this.items.get(id) ?? null;
-	}
-	async findByDomain(domain) {
-		for (const a of this.items.values()) if (a.domain?.toLowerCase() === domain.toLowerCase()) return a;
-		return null;
-	}
-	async list(filter = {}) {
-		return [...this.items.values()].filter((a) => {
-			if (filter.ownerId !== void 0 && a.ownerId !== filter.ownerId) return false;
-			if (filter.industry !== void 0 && a.industry !== filter.industry) return false;
-			if (filter.domain !== void 0 && a.domain?.toLowerCase() !== filter.domain.toLowerCase()) return false;
-			if (filter.tags && filter.tags.length > 0) {
-				const at = new Set(a.tags ?? []);
-				if (!filter.tags.every((t) => at.has(t))) return false;
-			}
-			return true;
-		});
-	}
-	async create(input) {
-		const now = this.clock.now();
-		const a = {
-			...input,
-			createdAt: now,
-			updatedAt: now
-		};
-		this.items.set(a.id, a);
-		return a;
-	}
-	async update(id, patch) {
-		const e = this.items.get(id);
-		if (!e) throw new Error(`Account '${id}' not found`);
-		const a = {
-			...e,
-			...patch,
-			id,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, a);
-		return a;
-	}
-	async delete(id) {
-		this.items.delete(id);
-	}
-};
-//#endregion
-//#region src/adapters/in-memory/activity-repository.ts
-var InMemoryActivityRepository = class {
-	items = /* @__PURE__ */ new Map();
-	constructor(clock = systemClock) {
-		this.clock = clock;
-	}
-	async findById(id) {
-		return this.items.get(id) ?? null;
-	}
-	async list(filter = {}) {
-		return [...this.items.values()].filter((a) => {
-			if (filter.subjectKind !== void 0 && a.subjectKind !== filter.subjectKind) return false;
-			if (filter.subjectId !== void 0 && a.subjectId !== filter.subjectId) return false;
-			if (filter.status !== void 0) {
-				if (!(Array.isArray(filter.status) ? filter.status : [filter.status]).includes(a.status)) return false;
-			}
-			if (filter.ownerId !== void 0 && a.ownerId !== filter.ownerId) return false;
-			if (filter.scheduledBetween !== void 0) {
-				if (!a.scheduledAt) return false;
-				if (a.scheduledAt < filter.scheduledBetween.from || a.scheduledAt > filter.scheduledBetween.to) return false;
-			}
-			return true;
-		});
-	}
-	async create(input) {
-		const now = this.clock.now();
-		const a = {
-			...input,
-			createdAt: now,
-			updatedAt: now
-		};
-		this.items.set(a.id, a);
-		return a;
-	}
-	async update(id, patch) {
-		const e = this.items.get(id);
-		if (!e) throw new Error(`Activity '${id}' not found`);
-		const a = {
-			...e,
-			...patch,
-			id,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, a);
-		return a;
-	}
-	async casStatus(id, expected, next, patch = {}) {
-		const e = this.items.get(id);
-		if (!e || e.status !== expected) return null;
-		const updated = {
-			...e,
-			...patch,
-			id,
-			status: next,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, updated);
-		return updated;
-	}
-};
-//#endregion
-//#region src/adapters/in-memory/contact-repository.ts
-var InMemoryContactRepository = class {
-	items = /* @__PURE__ */ new Map();
-	constructor(clock = systemClock) {
-		this.clock = clock;
-	}
-	async findById(id) {
-		return this.items.get(id) ?? null;
-	}
-	async findByEmail(email) {
-		const needle = email.toLowerCase();
-		for (const c of this.items.values()) if (c.contact.email?.toLowerCase() === needle) return c;
-		return null;
-	}
-	async list(filter = {}) {
-		const email = filter.email?.toLowerCase();
-		return [...this.items.values()].filter((c) => {
-			if (filter.accountId !== void 0 && c.accountId !== filter.accountId) return false;
-			if (filter.ownerId !== void 0 && c.ownerId !== filter.ownerId) return false;
-			if (email !== void 0 && c.contact.email?.toLowerCase() !== email) return false;
-			if (filter.tags && filter.tags.length > 0) {
-				const ct = new Set(c.tags ?? []);
-				if (!filter.tags.every((t) => ct.has(t))) return false;
-			}
-			return true;
-		});
-	}
-	async create(input) {
-		const now = this.clock.now();
-		const c = {
-			...input,
-			createdAt: now,
-			updatedAt: now
-		};
-		this.items.set(c.id, c);
-		return c;
-	}
-	async update(id, patch) {
-		const e = this.items.get(id);
-		if (!e) throw new Error(`Contact '${id}' not found`);
-		const c = {
-			...e,
-			...patch,
-			id,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, c);
-		return c;
-	}
-	async delete(id) {
-		this.items.delete(id);
-	}
-};
-//#endregion
-//#region src/adapters/in-memory/event-transport.ts
-var InMemoryEventTransport = class {
-	name = "crm-in-memory";
-	events = [];
-	subscribers = [];
-	async publish(event) {
-		this.events.push(event);
-		for (const subscriber of this.subscribers) {
-			if (!matchEventPattern(subscriber.pattern, event.type)) continue;
-			await subscriber.handler(event);
-		}
-	}
-	async subscribe(pattern, handler) {
-		const entry = {
-			pattern,
-			handler
-		};
-		this.subscribers.push(entry);
-		return async () => {
-			const idx = this.subscribers.indexOf(entry);
-			if (idx >= 0) this.subscribers.splice(idx, 1);
-		};
-	}
-};
-//#endregion
-//#region src/adapters/in-memory/lead-repository.ts
-var InMemoryLeadRepository = class {
-	items = /* @__PURE__ */ new Map();
-	constructor(clock = systemClock) {
-		this.clock = clock;
-	}
-	async findById(id) {
-		return this.items.get(id) ?? null;
-	}
-	async findByEmail(email) {
-		for (const l of this.items.values()) if (l.email?.toLowerCase() === email.toLowerCase()) return l;
-		return null;
-	}
-	async list(filter = {}) {
-		return [...this.items.values()].filter((l) => {
-			if (filter.status !== void 0) {
-				if (!(Array.isArray(filter.status) ? filter.status : [filter.status]).includes(l.status)) return false;
-			}
-			if (filter.ownerId !== void 0 && l.ownerId !== filter.ownerId) return false;
-			if (filter.source !== void 0 && l.source !== filter.source) return false;
-			if (filter.minScore !== void 0 && (l.score ?? 0) < filter.minScore) return false;
-			return true;
-		});
-	}
-	async create(input) {
-		const now = this.clock.now();
-		const l = {
-			...input,
-			createdAt: now,
-			updatedAt: now
-		};
-		this.items.set(l.id, l);
-		return l;
-	}
-	async update(id, patch) {
-		const e = this.items.get(id);
-		if (!e) throw new Error(`Lead '${id}' not found`);
-		const l = {
-			...e,
-			...patch,
-			id,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, l);
-		return l;
-	}
-	async casStatus(id, expected, next, patch = {}) {
-		const e = this.items.get(id);
-		if (!e || e.status !== expected) return null;
-		const updated = {
-			...e,
-			...patch,
-			id,
-			status: next,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, updated);
-		return updated;
-	}
-};
-//#endregion
-//#region src/adapters/in-memory/loss-reason-repository.ts
-var InMemoryLossReasonRepository = class {
-	items = /* @__PURE__ */ new Map();
-	constructor(clock = systemClock) {
-		this.clock = clock;
-	}
-	async findById(id) {
-		return this.items.get(id) ?? null;
-	}
-	async list(activeOnly = true) {
-		return [...this.items.values()].filter((r) => activeOnly ? r.active : true);
-	}
-	async create(input) {
-		const now = this.clock.now();
-		const r = {
-			...input,
-			createdAt: now,
-			updatedAt: now
-		};
-		this.items.set(r.id, r);
-		return r;
-	}
-	async update(id, patch) {
-		const e = this.items.get(id);
-		if (!e) throw new Error(`LossReason '${id}' not found`);
-		const r = {
-			...e,
-			...patch,
-			id,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, r);
-		return r;
-	}
-};
-//#endregion
-//#region src/adapters/in-memory/note-repository.ts
-var InMemoryNoteRepository = class {
-	items = /* @__PURE__ */ new Map();
-	constructor(clock = systemClock) {
-		this.clock = clock;
-	}
-	async findById(id) {
-		return this.items.get(id) ?? null;
-	}
-	async listBySubject(subjectKind, subjectId) {
-		return [...this.items.values()].filter((n) => n.subjectKind === subjectKind && n.subjectId === subjectId);
-	}
-	async create(input) {
-		const now = this.clock.now();
-		const n = {
-			...input,
-			createdAt: now,
-			updatedAt: now
-		};
-		this.items.set(n.id, n);
-		return n;
-	}
-	async update(id, patch) {
-		const e = this.items.get(id);
-		if (!e) throw new Error(`Note '${id}' not found`);
-		const n = {
-			...e,
-			...patch,
-			id,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, n);
-		return n;
-	}
-	async delete(id) {
-		this.items.delete(id);
-	}
-};
-//#endregion
-//#region src/adapters/in-memory/opportunity-repository.ts
-var InMemoryOpportunityRepository = class {
-	items = /* @__PURE__ */ new Map();
-	constructor(clock = systemClock) {
-		this.clock = clock;
-	}
-	async findById(id) {
-		return this.items.get(id) ?? null;
-	}
-	async list(filter = {}) {
-		return [...this.items.values()].filter((o) => {
-			if (filter.status !== void 0) {
-				if (!(Array.isArray(filter.status) ? filter.status : [filter.status]).includes(o.status)) return false;
-			}
-			if (filter.pipelineId !== void 0 && o.pipelineId !== filter.pipelineId) return false;
-			if (filter.stageId !== void 0 && o.stageId !== filter.stageId) return false;
-			if (filter.ownerId !== void 0 && o.ownerId !== filter.ownerId) return false;
-			if (filter.accountId !== void 0 && o.accountId !== filter.accountId) return false;
-			if (filter.closingBetween !== void 0) {
-				if (!o.expectedCloseAt) return false;
-				if (o.expectedCloseAt < filter.closingBetween.from || o.expectedCloseAt > filter.closingBetween.to) return false;
-			}
-			return true;
-		});
-	}
-	async create(input) {
-		const now = this.clock.now();
-		const o = {
-			...input,
-			createdAt: now,
-			updatedAt: now
-		};
-		this.items.set(o.id, o);
-		return o;
-	}
-	async update(id, patch) {
-		const e = this.items.get(id);
-		if (!e) throw new Error(`Opportunity '${id}' not found`);
-		const o = {
-			...e,
-			...patch,
-			id,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, o);
-		return o;
-	}
-	async delete(id) {
-		this.items.delete(id);
-	}
-	async casStatus(id, expected, next, patch = {}) {
-		const e = this.items.get(id);
-		if (!e || e.status !== expected) return null;
-		const updated = {
-			...e,
-			...patch,
-			id,
-			status: next,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, updated);
-		return updated;
-	}
-	async casStage(id, expectedStageId, nextStageId, patch = {}) {
-		const e = this.items.get(id);
-		if (!e || e.stageId !== expectedStageId) return null;
-		const updated = {
-			...e,
-			...patch,
-			id,
-			stageId: nextStageId,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, updated);
-		return updated;
-	}
-};
-//#endregion
-//#region src/adapters/in-memory/pipeline-repository.ts
-var InMemoryPipelineRepository = class {
-	items = /* @__PURE__ */ new Map();
-	constructor(clock = systemClock) {
-		this.clock = clock;
-	}
-	async findById(id) {
-		return this.items.get(id) ?? null;
-	}
-	async list(includeArchived = false) {
-		return [...this.items.values()].filter((p) => includeArchived || !p.isArchived);
-	}
-	async create(input) {
-		const now = this.clock.now();
-		const p = {
-			...input,
-			createdAt: now,
-			updatedAt: now
-		};
-		this.items.set(p.id, p);
-		return p;
-	}
-	async update(id, patch) {
-		const e = this.items.get(id);
-		if (!e) throw new Error(`Pipeline '${id}' not found`);
-		const p = {
-			...e,
-			...patch,
-			id,
-			updatedAt: this.clock.now()
-		};
-		this.items.set(id, p);
-		return p;
-	}
-};
-//#endregion
-//#region src/adapters/in-memory/outreach-port.ts
-var NullOutreachPort = class {
-	counter = 0;
-	async send(_request) {
-		return {
-			providerMessageId: `null_msg_${++this.counter}`,
-			acceptedAt: /* @__PURE__ */ new Date()
-		};
-	}
-};
-var InMemoryOutreachPort = class {
-	sent = [];
-	counter = 0;
-	constructor(nowMs = () => Date.now()) {
-		this.nowMs = nowMs;
-	}
-	async send(request) {
-		const res = {
-			providerMessageId: `msg_${++this.counter}`,
-			acceptedAt: new Date(this.nowMs())
-		};
-		this.sent.push({
-			...request,
-			...res
-		});
-		return res;
-	}
-};
-//#endregion
-//#region src/events/event-catalog.ts
+//#region src/validators/common.ts
 /**
-* CRM event catalog — Zod-source-of-truth definitions for every
-* `crm:*` event.
-*
-* Each definition exposes:
-*   - `.zodSchema`   — source of truth, used by host code's `.safeParse()`
-*   - `.schema`      — JSON Schema derived via `z.toJSONSchema()`, consumed
-*                     by Arc's EventRegistry + OpenAPI plugin
-*   - `.create(...)` — DomainEvent envelope builder, structurally compatible
-*                     with `@classytic/arc`'s `EventDefinitionOutput`
-*
-* Structurally compatible with Arc 2.10's `EventRegistry` — hosts register
-* `crmEventDefinitions` directly, no adapter code. CRM does NOT import from
-* `@classytic/arc` (PACKAGE_RULES §11); compatibility is purely structural.
-*
-* Timestamps are modelled as `z.iso.datetime()` — events cross the wire and
-* JSON Schema cannot represent `Date` (PACKAGE_RULES §18.5 + §25). Subscribers
-* that need a `Date` instance call `new Date(payload.completedAt)`.
-*
-* @example Wiring into an Arc app
-* ```ts
-* import { createEventRegistry } from '@classytic/arc/events';
-* import { crmEventDefinitions } from '@classytic/crm';
-*
-* const registry = createEventRegistry();
-* for (const def of crmEventDefinitions) registry.register(def);
-*
-* const app = await createApp({
-*   arcPlugins: { events: { registry, validateMode: 'reject' } },
-* });
-* ```
+* Shared zod primitives — `objectIdLike` (string-or-objectId), metadata
+* record, tag list. Centralised so every resource validator is consistent.
 */
-function defineCrmEvent(input) {
-	const { name, version = 1, description, zodSchema } = input;
-	const def = {
-		name,
-		version,
-		schema: z.toJSONSchema(zodSchema),
-		zodSchema,
-		create(payload, meta) {
-			return createEvent(name, payload, {
-				source: "crm",
-				...meta
-			});
-		}
-	};
-	if (description !== void 0) def.description = description;
-	return def;
-}
-const money = z.object({
-	amount: z.number().nonnegative(),
-	currency: z.string().length(3)
-});
-const subjectKind = z.enum([
-	"lead",
-	"contact",
-	"account",
-	"opportunity"
-]);
-const stageRef = z.object({
-	stageId: z.string(),
-	sequence: z.number().int().nonnegative()
-});
-const leadCreatedSchema = z.object({
-	leadId: z.string(),
-	email: z.string().optional(),
-	score: z.number().optional()
-});
-const leadStatusChangedSchema = z.object({
-	leadId: z.string(),
-	from: z.string(),
-	to: z.string()
-});
-const leadScoredSchema = z.object({
-	leadId: z.string(),
-	score: z.number()
-});
-const leadConvertedSchema = z.object({
-	leadId: z.string(),
-	contactId: z.string(),
-	accountId: z.string().optional(),
-	opportunityId: z.string()
+const objectIdLike = z.union([z.string().min(1), z.string()]);
+const metadataSchema = z.record(z.string(), z.unknown()).optional();
+const tagsSchema = z.array(z.string().min(1).max(64)).max(50).optional();
+const moneyAmountSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+const currencyCodeSchema = z.string().regex(/^[A-Z]{3}$/, "Currency must be a 3-letter ISO code");
+//#endregion
+//#region src/validators/pipeline.schema.ts
+const stageInputSchema = z.object({
+	name: z.string().min(1).max(100),
+	sequence: z.number().int().min(1),
+	defaultProbability: z.number().min(0).max(1),
+	color: z.string().max(32).optional(),
+	description: z.string().max(500).optional()
 });
-const leadDisqualifiedSchema = z.object({
-	leadId: z.string(),
-	reason: z.string()
+const createPipelineSchema = z.object({
+	name: z.string().min(1).max(200),
+	stages: z.array(stageInputSchema).default([]),
+	teamRef: z.string().max(100).optional(),
+	metadata: metadataSchema
 });
-const accountCreatedSchema = z.object({ accountId: z.string() });
-const accountUpdatedSchema = z.object({ accountId: z.string() });
-const contactCreatedSchema = z.object({
-	contactId: z.string(),
-	email: z.string().optional()
+const updatePipelineSchema = createPipelineSchema.partial();
+const stageInputSchemaExport = stageInputSchema;
+const pipelineFilterSchema = z.object({
+	isArchived: z.coerce.boolean().optional(),
+	teamRef: z.string().optional()
 });
-const contactUpdatedSchema = z.object({ contactId: z.string() });
-const opportunityCreatedSchema = z.object({
-	opportunityId: z.string(),
-	pipelineId: z.string(),
-	stageId: z.string()
+//#endregion
+//#region src/validators/lead.schema.ts
+const leadFieldsSchema = z.object({
+	fullName: z.string().min(1).max(200).optional(),
+	firstName: z.string().min(1).max(100).optional(),
+	lastName: z.string().min(1).max(100).optional(),
+	email: z.string().email().max(255).optional(),
+	phone: z.string().min(3).max(50).optional(),
+	companyName: z.string().min(1).max(200).optional(),
+	jobTitle: z.string().min(1).max(150).optional(),
+	source: z.string().min(1).max(100).optional(),
+	campaignRef: z.string().min(1).max(100).optional(),
+	ownerId: z.string().optional(),
+	tags: tagsSchema,
+	metadata: metadataSchema
 });
-const opportunityStageAdvancedSchema = z.object({
-	opportunityId: z.string(),
-	from: stageRef,
-	to: stageRef
+const createLeadSchema = leadFieldsSchema.refine((v) => v.fullName || v.firstName || v.lastName || v.email || v.phone, "Lead must have at least one of fullName, firstName/lastName, email, phone");
+const updateLeadSchema = leadFieldsSchema.partial().refine((v) => Object.keys(v).length > 0, "updateLead requires at least one field");
+const leadFilterSchema = z.object({
+	status: z.enum(LEAD_STATUSES).optional(),
+	ownerId: z.string().optional(),
+	email: z.string().optional(),
+	tags: z.array(z.string()).optional(),
+	source: z.string().optional(),
+	campaignRef: z.string().optional(),
+	scoreMin: z.number().int().optional(),
+	scoreMax: z.number().int().optional()
 });
-const opportunityStageRegressedSchema = opportunityStageAdvancedSchema;
-const opportunityWonSchema = z.object({
-	opportunityId: z.string(),
-	amount: money.optional()
+const convertLeadSchema = z.object({
+	pipelineId: objectIdLike,
+	opportunityName: z.string().min(1).max(200).optional(),
+	amount: z.number().nonnegative().optional(),
+	currency: z.string().regex(/^[A-Z]{3}$/).optional(),
+	expectedCloseAt: z.coerce.date().optional(),
+	by: z.string().optional()
 });
-const opportunityLostSchema = z.object({
-	opportunityId: z.string(),
-	lostReasonId: z.string().optional()
+//#endregion
+//#region src/validators/opportunity.schema.ts
+const openOpportunitySchema = z.object({
+	name: z.string().min(1).max(200),
+	pipelineId: objectIdLike,
+	stageId: z.string().optional(),
+	accountId: objectIdLike.optional(),
+	primaryContactId: objectIdLike.optional(),
+	sourceLeadId: objectIdLike.optional(),
+	amount: z.number().nonnegative().optional(),
+	currency: currencyCodeSchema.optional(),
+	probability: z.number().min(0).max(1).optional(),
+	expectedCloseAt: z.coerce.date().optional(),
+	ownerId: z.string().optional(),
+	tags: tagsSchema,
+	metadata: metadataSchema
 });
-const opportunityAbandonedSchema = z.object({ opportunityId: z.string() });
-const pipelineCreatedSchema = z.object({ pipelineId: z.string() });
-const pipelineArchivedSchema = z.object({ pipelineId: z.string() });
-const activityPlannedSchema = z.object({
-	activityId: z.string(),
-	type: z.string(),
-	subjectKind,
-	subjectId: z.string()
+const moveStageSchema = z.object({
+	stageId: z.string().min(1),
+	by: z.string().optional(),
+	note: z.string().max(500).optional(),
+	probability: z.number().min(0).max(1).optional()
 });
-const activityCompletedSchema = z.object({
-	activityId: z.string(),
-	completedAt: z.iso.datetime()
+const closeWinSchema = z.object({
+	by: z.string().optional(),
+	note: z.string().max(500).optional(),
+	closedAt: z.coerce.date().optional(),
+	amount: z.number().nonnegative().optional()
 });
-const activityCancelledSchema = z.object({
-	activityId: z.string(),
-	reason: z.string().optional()
+const closeLossSchema = z.object({
+	by: z.string().optional(),
+	note: z.string().max(500).optional(),
+	closedAt: z.coerce.date().optional(),
+	lostReasonId: objectIdLike.optional()
 });
-const noteAddedSchema = z.object({
-	noteId: z.string(),
-	subjectKind,
-	subjectId: z.string()
+const opportunityFilterSchema = z.object({
+	status: z.enum(OPPORTUNITY_STATUSES).optional(),
+	pipelineId: objectIdLike.optional(),
+	stageId: z.string().optional(),
+	ownerId: z.string().optional(),
+	accountId: objectIdLike.optional(),
+	expectedCloseFrom: z.coerce.date().optional(),
+	expectedCloseTo: z.coerce.date().optional()
 });
-const LeadCreated = defineCrmEvent({
-	name: CRM_EVENTS.LEAD_CREATED,
-	description: "A new lead was captured and initial score computed.",
-	zodSchema: leadCreatedSchema
+//#endregion
+//#region src/validators/contact.schema.ts
+const contactNameSchema = z.object({
+	given: z.string().min(1).max(100),
+	family: z.string().min(0).max(100).default(""),
+	middle: z.string().max(100).optional(),
+	prefix: z.string().max(32).optional(),
+	suffix: z.string().max(32).optional(),
+	preferred: z.string().max(100).optional()
 });
-const LeadStatusChanged = defineCrmEvent({
-	name: CRM_EVENTS.LEAD_STATUS_CHANGED,
-	description: "A lead transitioned between lifecycle statuses.",
-	zodSchema: leadStatusChangedSchema
+const contactInfoSchema = z.object({
+	email: z.string().email().max(255).optional(),
+	personalEmail: z.string().email().max(255).optional(),
+	phone: z.string().max(50).optional(),
+	alternatePhone: z.string().max(50).optional()
 });
-const LeadScored = defineCrmEvent({
-	name: CRM_EVENTS.LEAD_SCORED,
-	description: "A lead score was recomputed and persisted.",
-	zodSchema: leadScoredSchema
+const createContactSchema = z.object({
+	name: contactNameSchema,
+	contact: contactInfoSchema.default({}),
+	jobTitle: z.string().max(150).optional(),
+	accountId: objectIdLike.optional(),
+	ownerId: z.string().optional(),
+	tags: tagsSchema,
+	metadata: metadataSchema
 });
-const LeadConverted = defineCrmEvent({
-	name: CRM_EVENTS.LEAD_CONVERTED,
-	description: "A lead was converted into a Contact + (optional) Account + Opportunity.",
-	zodSchema: leadConvertedSchema
+const updateContactSchema = createContactSchema.partial();
+const contactFilterSchema = z.object({
+	accountId: objectIdLike.optional(),
+	ownerId: z.string().optional(),
+	email: z.string().optional(),
+	tags: z.array(z.string()).optional()
 });
-const LeadDisqualified = defineCrmEvent({
-	name: CRM_EVENTS.LEAD_DISQUALIFIED,
-	description: "A lead was disqualified with a reason.",
-	zodSchema: leadDisqualifiedSchema
+//#endregion
+//#region src/validators/account.schema.ts
+const createAccountSchema = z.object({
+	name: z.string().min(1).max(200),
+	domain: z.string().max(255).optional(),
+	industry: z.string().max(100).optional(),
+	sizeBucket: z.string().max(20).optional(),
+	annualRevenueAmount: z.number().nonnegative().optional(),
+	annualRevenueCurrency: currencyCodeSchema.optional(),
+	ownerId: z.string().optional(),
+	tags: tagsSchema,
+	metadata: metadataSchema
 });
-const AccountCreated = defineCrmEvent({
-	name: CRM_EVENTS.ACCOUNT_CREATED,
-	description: "A new account was created.",
-	zodSchema: accountCreatedSchema
+const updateAccountSchema = createAccountSchema.partial();
+const accountFilterSchema = z.object({
+	domain: z.string().optional(),
+	industry: z.string().optional(),
+	ownerId: z.string().optional(),
+	tags: z.array(z.string()).optional()
 });
-const AccountUpdated = defineCrmEvent({
-	name: CRM_EVENTS.ACCOUNT_UPDATED,
-	description: "An account record was updated.",
-	zodSchema: accountUpdatedSchema
+//#endregion
+//#region src/validators/campaign.schema.ts
+const createCampaignSchema = z.object({
+	name: z.string().min(1).max(200),
+	description: z.string().max(2e3).optional(),
+	utmSource: z.string().max(100).optional(),
+	utmMedium: z.string().max(100).optional(),
+	utmCampaign: z.string().max(100).optional(),
+	startDate: z.coerce.date().optional(),
+	endDate: z.coerce.date().optional(),
+	budgetAmount: z.number().nonnegative().optional(),
+	expectedRevenueAmount: z.number().nonnegative().optional(),
+	currency: currencyCodeSchema.optional(),
+	ownerId: z.string().optional(),
+	tags: tagsSchema,
+	metadata: metadataSchema
 });
-const ContactCreated = defineCrmEvent({
-	name: CRM_EVENTS.CONTACT_CREATED,
-	description: "A new contact was created.",
-	zodSchema: contactCreatedSchema
+const updateCampaignSchema = createCampaignSchema.partial();
+const completeCampaignSchema = z.object({
+	by: z.string().optional(),
+	note: z.string().max(500).optional(),
+	actualRevenueAmount: z.number().nonnegative().optional()
 });
-const ContactUpdated = defineCrmEvent({
-	name: CRM_EVENTS.CONTACT_UPDATED,
-	description: "A contact record was updated.",
-	zodSchema: contactUpdatedSchema
+const campaignFilterSchema = z.object({
+	status: z.enum(CAMPAIGN_STATUSES).optional(),
+	ownerId: z.string().optional(),
+	tags: z.array(z.string()).optional(),
+	startDateFrom: z.coerce.date().optional(),
+	startDateTo: z.coerce.date().optional()
 });
-const OpportunityCreated = defineCrmEvent({
-	name: CRM_EVENTS.OPPORTUNITY_CREATED,
-	description: "A new opportunity was created in a pipeline at a starting stage.",
-	zodSchema: opportunityCreatedSchema
+//#endregion
+//#region src/validators/subscription.schema.ts
+const subscribeSchema = z.object({
+	contactId: objectIdLike,
+	campaignId: objectIdLike,
+	source: z.string().max(100).optional(),
+	consentIpAddress: z.string().max(64).optional(),
+	consentUserAgent: z.string().max(500).optional(),
+	metadata: metadataSchema,
+	requireDoubleOptIn: z.boolean().optional()
 });
-const OpportunityStageAdvanced = defineCrmEvent({
-	name: CRM_EVENTS.OPPORTUNITY_STAGE_ADVANCED,
-	description: "An opportunity moved to a later stage in its pipeline.",
-	zodSchema: opportunityStageAdvancedSchema
+const confirmSubscriptionSchema = z.object({ token: z.string().min(1).max(200) });
+const unsubscribeSchema = z.object({
+	token: z.string().min(1).max(200),
+	reason: z.string().max(500).optional()
 });
-const OpportunityStageRegressed = defineCrmEvent({
-	name: CRM_EVENTS.OPPORTUNITY_STAGE_REGRESSED,
-	description: "An opportunity moved back to an earlier stage in its pipeline.",
-	zodSchema: opportunityStageRegressedSchema
+const subscriptionFilterSchema = z.object({
+	status: z.enum(SUBSCRIPTION_STATUSES).optional(),
+	contactId: objectIdLike.optional(),
+	campaignId: objectIdLike.optional()
 });
-const OpportunityWon = defineCrmEvent({
-	name: CRM_EVENTS.OPPORTUNITY_WON,
-	description: "An opportunity closed as won.",
-	zodSchema: opportunityWonSchema
+//#endregion
+//#region src/validators/activity.schema.ts
+const planActivitySchema = z.object({
+	type: z.enum(ACTIVITY_TYPES),
+	subjectKind: z.enum(SUBJECT_KINDS),
+	subjectId: objectIdLike,
+	title: z.string().min(1).max(200),
+	description: z.string().max(2e3).optional(),
+	ownerId: z.string().optional(),
+	participantIds: z.array(z.string()).max(50).optional(),
+	dueDate: z.coerce.date().optional(),
+	externalRef: z.string().max(200).optional(),
+	metadata: metadataSchema
 });
-const OpportunityLost = defineCrmEvent({
-	name: CRM_EVENTS.OPPORTUNITY_LOST,
-	description: "An opportunity closed as lost.",
-	zodSchema: opportunityLostSchema
+const updateActivitySchema = planActivitySchema.partial();
+const cancelActivitySchema = z.object({ reason: z.string().max(500).optional() });
+const activityFilterSchema = z.object({
+	type: z.enum(ACTIVITY_TYPES).optional(),
+	status: z.enum(ACTIVITY_STATUSES).optional(),
+	subjectKind: z.enum(SUBJECT_KINDS).optional(),
+	subjectId: objectIdLike.optional(),
+	ownerId: z.string().optional(),
+	dueDateFrom: z.coerce.date().optional(),
+	dueDateTo: z.coerce.date().optional()
 });
-const OpportunityAbandoned = defineCrmEvent({
-	name: CRM_EVENTS.OPPORTUNITY_ABANDONED,
-	description: "An opportunity was abandoned without a close outcome.",
-	zodSchema: opportunityAbandonedSchema
+//#endregion
+//#region src/validators/note.schema.ts
+const addNoteSchema = z.object({
+	subjectKind: z.enum(SUBJECT_KINDS),
+	subjectId: objectIdLike,
+	body: z.string().min(1).max(1e4),
+	authorId: z.string().optional(),
+	pinned: z.boolean().optional(),
+	metadata: metadataSchema
 });
-const PipelineCreated = defineCrmEvent({
-	name: CRM_EVENTS.PIPELINE_CREATED,
-	description: "A new pipeline was created.",
-	zodSchema: pipelineCreatedSchema
+const updateNoteSchema = z.object({
+	body: z.string().min(1).max(1e4).optional(),
+	pinned: z.boolean().optional(),
+	metadata: metadataSchema
 });
-const PipelineArchived = defineCrmEvent({
-	name: CRM_EVENTS.PIPELINE_ARCHIVED,
-	description: "A pipeline was archived.",
-	zodSchema: pipelineArchivedSchema
+const noteFilterSchema = z.object({
+	subjectKind: z.enum(SUBJECT_KINDS).optional(),
+	subjectId: objectIdLike.optional(),
+	authorId: z.string().optional(),
+	pinned: z.coerce.boolean().optional()
 });
-const ActivityPlanned = defineCrmEvent({
-	name: CRM_EVENTS.ACTIVITY_PLANNED,
-	description: "An activity was planned against a polymorphic subject.",
-	zodSchema: activityPlannedSchema
+//#endregion
+//#region src/validators/loss-reason.schema.ts
+const createLossReasonSchema = z.object({
+	name: z.string().min(1).max(200),
+	description: z.string().max(1e3).optional(),
+	isActive: z.boolean().optional(),
+	sequence: z.number().int().min(0).optional(),
+	metadata: metadataSchema
 });
-const ActivityCompleted = defineCrmEvent({
-	name: CRM_EVENTS.ACTIVITY_COMPLETED,
-	description: "An activity was marked completed.",
-	zodSchema: activityCompletedSchema
+const updateLossReasonSchema = createLossReasonSchema.partial();
+const lossReasonFilterSchema = z.object({ isActive: z.coerce.boolean().optional() });
+//#endregion
+//#region src/validators/email-event.schema.ts
+const recordEmailEventSchema = z.object({
+	subjectKind: z.enum(EMAIL_EVENT_SUBJECT_KINDS),
+	subjectId: objectIdLike,
+	campaignId: objectIdLike.optional(),
+	messageId: z.string().max(200).optional(),
+	url: z.string().max(2048).optional(),
+	userAgent: z.string().max(500).optional(),
+	ip: z.string().max(64).optional(),
+	metadata: metadataSchema
 });
-const ActivityCancelled = defineCrmEvent({
-	name: CRM_EVENTS.ACTIVITY_CANCELLED,
-	description: "An activity was cancelled.",
-	zodSchema: activityCancelledSchema
+const emailEventFilterSchema = z.object({
+	kind: z.enum(EMAIL_EVENT_KINDS).optional(),
+	subjectKind: z.enum(EMAIL_EVENT_SUBJECT_KINDS).optional(),
+	subjectId: objectIdLike.optional(),
+	campaignId: objectIdLike.optional(),
+	messageId: z.string().optional()
 });
-const NoteAdded = defineCrmEvent({
-	name: CRM_EVENTS.NOTE_ADDED,
-	description: "A note was attached to a polymorphic subject.",
-	zodSchema: noteAddedSchema
+//#endregion
+//#region src/validators/index.ts
+var validators_exports = /* @__PURE__ */ __exportAll({
+	accountFilterSchema: () => accountFilterSchema,
+	activityFilterSchema: () => activityFilterSchema,
+	addNoteSchema: () => addNoteSchema,
+	campaignFilterSchema: () => campaignFilterSchema,
+	cancelActivitySchema: () => cancelActivitySchema,
+	closeLossSchema: () => closeLossSchema,
+	closeWinSchema: () => closeWinSchema,
+	completeCampaignSchema: () => completeCampaignSchema,
+	confirmSubscriptionSchema: () => confirmSubscriptionSchema,
+	contactFilterSchema: () => contactFilterSchema,
+	convertLeadSchema: () => convertLeadSchema,
+	createAccountSchema: () => createAccountSchema,
+	createCampaignSchema: () => createCampaignSchema,
+	createContactSchema: () => createContactSchema,
+	createLeadSchema: () => createLeadSchema,
+	createLossReasonSchema: () => createLossReasonSchema,
+	createPipelineSchema: () => createPipelineSchema,
+	currencyCodeSchema: () => currencyCodeSchema,
+	emailEventFilterSchema: () => emailEventFilterSchema,
+	leadFilterSchema: () => leadFilterSchema,
+	lossReasonFilterSchema: () => lossReasonFilterSchema,
+	metadataSchema: () => metadataSchema,
+	moneyAmountSchema: () => moneyAmountSchema,
+	moveStageSchema: () => moveStageSchema,
+	noteFilterSchema: () => noteFilterSchema,
+	objectIdLike: () => objectIdLike,
+	openOpportunitySchema: () => openOpportunitySchema,
+	opportunityFilterSchema: () => opportunityFilterSchema,
+	pipelineFilterSchema: () => pipelineFilterSchema,
+	planActivitySchema: () => planActivitySchema,
+	recordEmailEventSchema: () => recordEmailEventSchema,
+	stageInputSchemaExport: () => stageInputSchemaExport,
+	subscribeSchema: () => subscribeSchema,
+	subscriptionFilterSchema: () => subscriptionFilterSchema,
+	tagsSchema: () => tagsSchema,
+	unsubscribeSchema: () => unsubscribeSchema,
+	updateAccountSchema: () => updateAccountSchema,
+	updateActivitySchema: () => updateActivitySchema,
+	updateCampaignSchema: () => updateCampaignSchema,
+	updateContactSchema: () => updateContactSchema,
+	updateLeadSchema: () => updateLeadSchema,
+	updateLossReasonSchema: () => updateLossReasonSchema,
+	updateNoteSchema: () => updateNoteSchema,
+	updatePipelineSchema: () => updatePipelineSchema
 });
-/**
-* Every CRM event defined in the package — pass to Arc's `EventRegistry`.
-* Hosts wire ONE array; the whole `crm:*` namespace becomes introspectable
-* via OpenAPI and auto-validated at publish time when
-* `eventPlugin({ validateMode: 'reject' })` is set.
-*/
-const crmEventDefinitions = [
-	LeadCreated,
-	LeadStatusChanged,
-	LeadScored,
-	LeadConverted,
-	LeadDisqualified,
-	AccountCreated,
-	AccountUpdated,
-	ContactCreated,
-	ContactUpdated,
-	OpportunityCreated,
-	OpportunityStageAdvanced,
-	OpportunityStageRegressed,
-	OpportunityWon,
-	OpportunityLost,
-	OpportunityAbandoned,
-	PipelineCreated,
-	PipelineArchived,
-	ActivityPlanned,
-	ActivityCompleted,
-	ActivityCancelled,
-	NoteAdded
-];
 //#endregion
-export { ACTIVITY_STATUSES, ACTIVITY_TRANSITIONS, ACTIVITY_TYPES, AccountCreated, AccountService, AccountUpdated, ActivityCancelled, ActivityCompleted, ActivityPlanned, ActivityService, CRM_EVENTS, ContactCreated, ContactService, ContactUpdated, CrmError, DuplicateLeadError, EmptyPipelineError, InMemoryAccountRepository, InMemoryActivityRepository, InMemoryContactRepository, InMemoryEventTransport, InMemoryLeadRepository, InMemoryLossReasonRepository, InMemoryNoteRepository, InMemoryOpportunityRepository, InMemoryOutreachPort, InMemoryPipelineRepository, InvalidActivityTransitionError, InvalidLeadTransitionError, InvalidOpportunityTransitionError, LEAD_STATUSES, LEAD_TRANSITIONS, LeadAlreadyConvertedError, LeadConverted, LeadCreated, LeadDisqualified, LeadScored, LeadService, LeadStatusChanged, NotFoundError, NoteAdded, NullOutreachPort, OPPORTUNITY_STATUSES, OPPORTUNITY_TRANSITIONS, OpportunityAbandoned, OpportunityCreated, OpportunityLost, OpportunityService, OpportunityStageAdvanced, OpportunityStageRegressed, OpportunityWon, PipelineArchived, PipelineCreated, PipelineService, SUBJECT_KINDS, StageNotInPipelineError, canTransitionActivity, canTransitionLead, canTransitionOpportunity, composeScorers, createSequentialIdGenerator, crmEventDefinitions, cryptoIdGenerator, defaultLeadScorer, forecast, pipelineConversion, systemClock };
+export { ACTIVITY_MACHINE, ACTIVITY_STATUSES, ACTIVITY_TRANSITIONS, ACTIVITY_TYPES, AccountRepository, ActivityRepository, CAMPAIGN_MACHINE, CAMPAIGN_STATUSES, CAMPAIGN_TRANSITIONS, CRM_EVENTS, CampaignRepository, ContactRepository, CrmError, DuplicateCampaignError, DuplicateLeadError, DuplicateSubscriptionError, EMAIL_EVENT_KINDS, EMAIL_EVENT_SUBJECT_KINDS, EmailEventRepository, EmptyPipelineError, InProcessCrmBus, InvalidActivityTransitionError, InvalidCampaignTransitionError, InvalidConfirmationTokenError, InvalidLeadTransitionError, InvalidOpportunityTransitionError, InvalidSubscriptionTransitionError, InvalidUnsubscribeTokenError, LEAD_MACHINE, LEAD_STATUSES, LEAD_TRANSITIONS, LeadAlreadyConvertedError, LeadRepository, LeadService, LossReasonRepository, NotFoundError, NoteRepository, OPPORTUNITY_MACHINE, OPPORTUNITY_STATUSES, OPPORTUNITY_TRANSITIONS, OpportunityRepository, PipelineRepository, SUBJECT_KINDS, SUBSCRIPTION_MACHINE, SUBSCRIPTION_STATUSES, SUBSCRIPTION_TRANSITIONS, StageNotInPipelineError, SubscriptionRepository, appendStatus, buildAccountSchema, buildActivitySchema, buildCampaignSchema, buildContactSchema, buildEmailEventSchema, buildLeadSchema, buildLossReasonSchema, buildNoteSchema, buildOpportunitySchema, buildPipelineSchema, buildSubscriptionSchema, canTransitionActivity, canTransitionCampaign, canTransitionLead, canTransitionOpportunity, canTransitionSubscription, composeScorers, createAccountModel, createActivityModel, createCampaignModel, createContactModel, createCrm, createCrmModels, createCrmRepositories, createEmailEventModel, createEvent, createLeadModel, createLossReasonModel, createNoteModel, createOpportunityModel, createPipelineModel, createSubscriptionModel, defaultLeadScorer, forecast, lastTransitionTo, latestEntry, pipelineConversion, tenantFieldDef, timeInStatus, validators_exports as validators };
 
 //# sourceMappingURL=index.js.map