@classytic/crm 0.1.0

package/dist/index.js

@@ -0,0 +1,1943 @@
+import { randomUUID } from "node:crypto";
+import { createEvent, matchEventPattern } from "@classytic/primitives/events";
+import { z } from "zod";
+//#region src/domain/errors.ts
+/**
+* CRM error vocabulary. Hosts catch `CrmError` at API edges.
+*/
+var CrmError = class extends Error {
+	code;
+	details;
+	constructor(code, message, details) {
+		super(message);
+		this.name = "CrmError";
+		this.code = code;
+		if (details !== void 0) this.details = details;
+	}
+};
+var NotFoundError = class extends CrmError {
+	constructor(kind, id) {
+		super(`${kind.toUpperCase()}_NOT_FOUND`, `${kind} '${id}' not found`, {
+			kind,
+			id
+		});
+	}
+};
+var InvalidLeadTransitionError = class extends CrmError {
+	constructor(details) {
+		super("INVALID_LEAD_TRANSITION", `Lead ${details.leadId} cannot move from '${details.from}' to '${details.to}'`, details);
+	}
+};
+var InvalidOpportunityTransitionError = class extends CrmError {
+	constructor(details) {
+		super("INVALID_OPPORTUNITY_TRANSITION", `Opportunity ${details.opportunityId} cannot move from '${details.from}' to '${details.to}'`, details);
+	}
+};
+var InvalidActivityTransitionError = class extends CrmError {
+	constructor(details) {
+		super("INVALID_ACTIVITY_TRANSITION", `Activity ${details.activityId} cannot move from '${details.from}' to '${details.to}'`, details);
+	}
+};
+var StageNotInPipelineError = class extends CrmError {
+	constructor(details) {
+		super("STAGE_NOT_IN_PIPELINE", `Stage '${details.stageId}' is not defined on pipeline '${details.pipelineId}'`, details);
+	}
+};
+var LeadAlreadyConvertedError = class extends CrmError {
+	constructor(leadId) {
+		super("LEAD_ALREADY_CONVERTED", `Lead '${leadId}' is already converted`, { leadId });
+	}
+};
+var DuplicateLeadError = class extends CrmError {
+	constructor(details) {
+		super("DUPLICATE_LEAD", `A lead with this email / phone already exists`, details);
+	}
+};
+var EmptyPipelineError = class extends CrmError {
+	constructor(pipelineId) {
+		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}` };
+}
+//#endregion
+//#region src/events/event-constants.ts
+/** PACKAGE_RULES rule 12: `package:resource.verb`. */
+const CRM_EVENTS = {
+	LEAD_CREATED: "crm:lead.created",
+	LEAD_STATUS_CHANGED: "crm:lead.status_changed",
+	LEAD_SCORED: "crm:lead.scored",
+	LEAD_CONVERTED: "crm:lead.converted",
+	LEAD_DISQUALIFIED: "crm:lead.disqualified",
+	ACCOUNT_CREATED: "crm:account.created",
+	ACCOUNT_UPDATED: "crm:account.updated",
+	CONTACT_CREATED: "crm:contact.created",
+	CONTACT_UPDATED: "crm:contact.updated",
+	OPPORTUNITY_CREATED: "crm:opportunity.created",
+	OPPORTUNITY_STAGE_ADVANCED: "crm:opportunity.stage_advanced",
+	OPPORTUNITY_STAGE_REGRESSED: "crm:opportunity.stage_regressed",
+	OPPORTUNITY_WON: "crm:opportunity.won",
+	OPPORTUNITY_LOST: "crm:opportunity.lost",
+	OPPORTUNITY_ABANDONED: "crm:opportunity.abandoned",
+	PIPELINE_CREATED: "crm:pipeline.created",
+	PIPELINE_ARCHIVED: "crm:pipeline.archived",
+	ACTIVITY_PLANNED: "crm:activity.planned",
+	ACTIVITY_COMPLETED: "crm:activity.completed",
+	ACTIVITY_CANCELLED: "crm:activity.cancelled",
+	NOTE_ADDED: "crm:note.added"
+};
+//#endregion
+//#region src/events/publish.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:
+*
+*   - 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.
+*/
+async function emitCrmEvent(transport, outbox, type, payload, meta = {}, session) {
+	if (!transport && !outbox) return;
+	const event = createEvent(type, payload, {
+		source: "crm",
+		...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;
+	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
+		});
+	}
+	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
+		});
+		return updated;
+	}
+	async _emit(event, payload, meta, options = {}) {
+		await emitCrmEvent(this.events, this.outbox, event, payload, meta, options.session);
+	}
+};
+//#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);
+		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
+/**
+* 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/services/scoring.ts
+/**
+* Reference implementation. Intentionally simple so hosts read it and
+* understand the shape, then 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)
+*/
+function defaultLeadScorer(lead) {
+	let score = 0;
+	if (lead.email) score += 20;
+	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
+	};
+}
+/**
+* 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;
+	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 = {}) {
+		if (this.rejectDuplicates && input.email) {
+			if (await this.repo.findByEmail(input.email)) throw new DuplicateLeadError({ email: input.email });
+		}
+		const now = this.clock.now();
+		const fullName = input.fullName ?? `${input.firstName ?? ""} ${input.lastName ?? ""}`.trim();
+		const draft = {
+			id: this.ids.next(),
+			fullName: fullName || input.email || input.phone || "Unknown",
+			status: "new",
+			statusHistory: [{
+				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;
+	}
+	async markContacted(id, by, note, options = {}) {
+		return this._transition(id, "contacted", {
+			...by !== void 0 ? { by } : {},
+			...note !== void 0 ? { note } : {}
+		}, options);
+	}
+	async qualify(id, by, note, options = {}) {
+		return this._transition(id, "qualified", {
+			...by !== void 0 ? { by } : {},
+			...note !== void 0 ? { note } : {}
+		}, options);
+	}
+	async disqualify(id, reason, by, options = {}) {
+		const updated = await this._transition(id, "disqualified", {
+			note: reason,
+			patch: { disqualifyReason: reason },
+			...by !== void 0 ? { by } : {}
+		}, options);
+		await this._emit(CRM_EVENTS.LEAD_DISQUALIFIED, {
+			leadId: id,
+			reason
+		}, void 0, options);
+		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);
+	}
+	list(filter) {
+		return this.repo.list(filter);
+	}
+	async _updateScore(lead, options = {}) {
+		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,
+			score
+		}, {
+			resource: "lead",
+			resourceId: lead.id
+		}, options);
+		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
+		});
+		const entry = {
+			status: target,
+			occurredAt: this.clock.now(),
+			...opts.by !== void 0 ? { by: opts.by } : {},
+			...opts.note !== void 0 ? { note: opts.note } : {}
+		};
+		const patch = {
+			...opts.patch ?? {},
+			statusHistory: [...existing.statusHistory, entry]
+		};
+		const updated = await this.repo.casStatus(id, existing.status, target, patch);
+		if (!updated) throw new InvalidLeadTransitionError({
+			from: (await this.repo.findById(id))?.status ?? existing.status,
+			to: target,
+			leadId: id
+		});
+		await this._emit(CRM_EVENTS.LEAD_STATUS_CHANGED, {
+			leadId: id,
+			from: existing.status,
+			to: target
+		}, {
+			resource: "lead",
+			resourceId: id
+		}, options);
+		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;
+	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(),
+			name: input.name,
+			pipelineId: pipeline.id,
+			stageId: stage.id,
+			status: "open",
+			statusHistory: [{
+				status: "open",
+				stageId: 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.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);
+		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 probability = input.probability ?? target.defaultProbability;
+		const now = this.clock.now();
+		const entry = {
+			status: "open",
+			stageId: target.id,
+			occurredAt: now,
+			...input.by !== void 0 ? { by: input.by } : {},
+			...input.note !== void 0 ? { note: input.note } : {}
+		};
+		const patch = {
+			probability,
+			statusHistory: [...existing.statusHistory, entry]
+		};
+		const updated = await this.repo.casStage(id, existing.stageId, target.id, patch);
+		if (!updated) throw new StageNotInPipelineError({
+			pipelineId: existing.pipelineId,
+			stageId: target.id
+		});
+		const eventName = target.sequence > currentStage.sequence ? CRM_EVENTS.OPPORTUNITY_STAGE_ADVANCED : CRM_EVENTS.OPPORTUNITY_STAGE_REGRESSED;
+		await this._emit(eventName, {
+			opportunityId: id,
+			from: {
+				stageId: currentStage.id,
+				sequence: currentStage.sequence
+			},
+			to: {
+				stageId: target.id,
+				sequence: target.sequence
+			}
+		}, {
+			resource: "opportunity",
+			resourceId: id
+		}, options);
+		return updated;
+	}
+	async win(id, input = {}, options = {}) {
+		const patch = {
+			closedAt: input.closedAt ?? this.clock.now(),
+			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, {
+			opportunityId: id,
+			amount: updated.amount
+		}, {
+			resource: "opportunity",
+			resourceId: id
+		}, options);
+		return updated;
+	}
+	async lose(id, input = {}, options = {}) {
+		const patch = {
+			closedAt: input.closedAt ?? this.clock.now(),
+			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);
+		return updated;
+	}
+	async abandon(id, by, note, options = {}) {
+		const patch = {
+			closedAt: this.clock.now(),
+			probability: 0
+		};
+		const updated = await this._transitionStatus(id, "abandoned", patch, by, note);
+		await this._emit(CRM_EVENTS.OPPORTUNITY_ABANDONED, { opportunityId: id }, {
+			resource: "opportunity",
+			resourceId: id
+		}, options);
+		return updated;
+	}
+	async delete(id) {
+		await this._require(id);
+		await this.repo.delete(id);
+	}
+	findById(id) {
+		return this.repo.findById(id);
+	}
+	list(filter) {
+		return this.repo.list(filter);
+	}
+	async _require(id) {
+		const o = await this.repo.findById(id);
+		if (!o) throw new NotFoundError("opportunity", id);
+		return o;
+	}
+	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 } : {}
+		};
+		const fullPatch = {
+			...patch,
+			statusHistory: [...existing.statusHistory, entry]
+		};
+		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);
+	}
+};
+//#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;
+	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 } : {}
+		});
+		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
+		});
+		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];
+	}
+	/** 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
+		});
+		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);
+	}
+};
+//#endregion
+//#region src/services/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.
+*/
+function forecast(opportunities, options = {}) {
+	const bucketFn = options.bucket ?? defaultBucket;
+	const include = options.include ?? defaultInclude;
+	const rows = /* @__PURE__ */ new Map();
+	for (const o of opportunities) {
+		if (!include(o)) continue;
+		const amt = o.amount.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().`);
+			rows.set(bucket, {
+				...existing,
+				committed: existing.committed + amt,
+				weighted: existing.weighted + Math.round(amt * o.probability),
+				count: existing.count + 1
+			});
+		} else rows.set(bucket, {
+			bucket,
+			committed: amt,
+			weighted: Math.round(amt * o.probability),
+			count: 1,
+			currency: o.amount.currency
+		});
+	}
+	return [...rows.values()].sort((a, b) => a.bucket.localeCompare(b.bucket));
+}
+function defaultInclude(o) {
+	return o.status === "open" && !!o.amount && !!o.expectedCloseAt;
+}
+function defaultBucket(o) {
+	const d = o.expectedCloseAt;
+	return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}`;
+}
+function pipelineConversion(opportunities, stageIds) {
+	return stageIds.map((stageId) => {
+		let currentCount = 0;
+		let wonFromHere = 0;
+		let lostFromHere = 0;
+		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++;
+				else lostFromHere++;
+			}
+		}
+		const closed = wonFromHere + lostFromHere;
+		return {
+			stageId,
+			currentCount,
+			wonFromHere,
+			lostFromHere,
+			conversionRate: closed > 0 ? wonFromHere / closed : 0
+		};
+	});
+}
+//#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
+/**
+* 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' } },
+* });
+* ```
+*/
+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 leadDisqualifiedSchema = z.object({
+	leadId: z.string(),
+	reason: z.string()
+});
+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 contactUpdatedSchema = z.object({ contactId: z.string() });
+const opportunityCreatedSchema = z.object({
+	opportunityId: z.string(),
+	pipelineId: z.string(),
+	stageId: z.string()
+});
+const opportunityStageAdvancedSchema = z.object({
+	opportunityId: z.string(),
+	from: stageRef,
+	to: stageRef
+});
+const opportunityStageRegressedSchema = opportunityStageAdvancedSchema;
+const opportunityWonSchema = z.object({
+	opportunityId: z.string(),
+	amount: money.optional()
+});
+const opportunityLostSchema = z.object({
+	opportunityId: z.string(),
+	lostReasonId: z.string().optional()
+});
+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 activityCompletedSchema = z.object({
+	activityId: z.string(),
+	completedAt: z.iso.datetime()
+});
+const activityCancelledSchema = z.object({
+	activityId: z.string(),
+	reason: z.string().optional()
+});
+const noteAddedSchema = z.object({
+	noteId: z.string(),
+	subjectKind,
+	subjectId: z.string()
+});
+const LeadCreated = defineCrmEvent({
+	name: CRM_EVENTS.LEAD_CREATED,
+	description: "A new lead was captured and initial score computed.",
+	zodSchema: leadCreatedSchema
+});
+const LeadStatusChanged = defineCrmEvent({
+	name: CRM_EVENTS.LEAD_STATUS_CHANGED,
+	description: "A lead transitioned between lifecycle statuses.",
+	zodSchema: leadStatusChangedSchema
+});
+const LeadScored = defineCrmEvent({
+	name: CRM_EVENTS.LEAD_SCORED,
+	description: "A lead score was recomputed and persisted.",
+	zodSchema: leadScoredSchema
+});
+const LeadConverted = defineCrmEvent({
+	name: CRM_EVENTS.LEAD_CONVERTED,
+	description: "A lead was converted into a Contact + (optional) Account + Opportunity.",
+	zodSchema: leadConvertedSchema
+});
+const LeadDisqualified = defineCrmEvent({
+	name: CRM_EVENTS.LEAD_DISQUALIFIED,
+	description: "A lead was disqualified with a reason.",
+	zodSchema: leadDisqualifiedSchema
+});
+const AccountCreated = defineCrmEvent({
+	name: CRM_EVENTS.ACCOUNT_CREATED,
+	description: "A new account was created.",
+	zodSchema: accountCreatedSchema
+});
+const AccountUpdated = defineCrmEvent({
+	name: CRM_EVENTS.ACCOUNT_UPDATED,
+	description: "An account record was updated.",
+	zodSchema: accountUpdatedSchema
+});
+const ContactCreated = defineCrmEvent({
+	name: CRM_EVENTS.CONTACT_CREATED,
+	description: "A new contact was created.",
+	zodSchema: contactCreatedSchema
+});
+const ContactUpdated = defineCrmEvent({
+	name: CRM_EVENTS.CONTACT_UPDATED,
+	description: "A contact record was updated.",
+	zodSchema: contactUpdatedSchema
+});
+const OpportunityCreated = defineCrmEvent({
+	name: CRM_EVENTS.OPPORTUNITY_CREATED,
+	description: "A new opportunity was created in a pipeline at a starting stage.",
+	zodSchema: opportunityCreatedSchema
+});
+const OpportunityStageAdvanced = defineCrmEvent({
+	name: CRM_EVENTS.OPPORTUNITY_STAGE_ADVANCED,
+	description: "An opportunity moved to a later stage in its pipeline.",
+	zodSchema: opportunityStageAdvancedSchema
+});
+const OpportunityStageRegressed = defineCrmEvent({
+	name: CRM_EVENTS.OPPORTUNITY_STAGE_REGRESSED,
+	description: "An opportunity moved back to an earlier stage in its pipeline.",
+	zodSchema: opportunityStageRegressedSchema
+});
+const OpportunityWon = defineCrmEvent({
+	name: CRM_EVENTS.OPPORTUNITY_WON,
+	description: "An opportunity closed as won.",
+	zodSchema: opportunityWonSchema
+});
+const OpportunityLost = defineCrmEvent({
+	name: CRM_EVENTS.OPPORTUNITY_LOST,
+	description: "An opportunity closed as lost.",
+	zodSchema: opportunityLostSchema
+});
+const OpportunityAbandoned = defineCrmEvent({
+	name: CRM_EVENTS.OPPORTUNITY_ABANDONED,
+	description: "An opportunity was abandoned without a close outcome.",
+	zodSchema: opportunityAbandonedSchema
+});
+const PipelineCreated = defineCrmEvent({
+	name: CRM_EVENTS.PIPELINE_CREATED,
+	description: "A new pipeline was created.",
+	zodSchema: pipelineCreatedSchema
+});
+const PipelineArchived = defineCrmEvent({
+	name: CRM_EVENTS.PIPELINE_ARCHIVED,
+	description: "A pipeline was archived.",
+	zodSchema: pipelineArchivedSchema
+});
+const ActivityPlanned = defineCrmEvent({
+	name: CRM_EVENTS.ACTIVITY_PLANNED,
+	description: "An activity was planned against a polymorphic subject.",
+	zodSchema: activityPlannedSchema
+});
+const ActivityCompleted = defineCrmEvent({
+	name: CRM_EVENTS.ACTIVITY_COMPLETED,
+	description: "An activity was marked completed.",
+	zodSchema: activityCompletedSchema
+});
+const ActivityCancelled = defineCrmEvent({
+	name: CRM_EVENTS.ACTIVITY_CANCELLED,
+	description: "An activity was cancelled.",
+	zodSchema: activityCancelledSchema
+});
+const NoteAdded = defineCrmEvent({
+	name: CRM_EVENTS.NOTE_ADDED,
+	description: "A note was attached to a polymorphic subject.",
+	zodSchema: noteAddedSchema
+});
+/**
+* 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 };
+
+//# sourceMappingURL=index.js.map