@happyvertical/smrt-sales 0.40.42 → 0.40.44

package/dist/chunks/{__smrt-register__-DJEOUcaR.js.map → __smrt-register__-_uoH8d0A.js.map}

@@ -1 +1 @@
-{"version":3,"file":"__smrt-register__-DJEOUcaR.js","names":[],"sources":["../../src/__smrt-register__.ts"],"sourcesContent":["import { ObjectRegistry } from '@happyvertical/smrt-core';\n\nObjectRegistry.registerPackageManifest(\n  new URL('./manifest.json', import.meta.url),\n);\n"],"mappings":""}
+{"version":3,"file":"__smrt-register__-_uoH8d0A.js","names":[],"sources":["../../src/__smrt-register__.ts"],"sourcesContent":["import { ObjectRegistry } from '@happyvertical/smrt-core';\n\nObjectRegistry.registerPackageManifest(\n  new URL('./manifest.json', import.meta.url),\n);\n"],"mappings":""}

package/dist/chunks/{crm-DwEz7E2r.js → crm-B8XqwUBg.js}

@@ -1,5 +1,5 @@
 import { SmrtCollection, SmrtObject, crossPackageRef, field, foreignKey, smrt } from "@happyvertical/smrt-core";
-import { TenantScoped, tenantId } from "@happyvertical/smrt-tenancy";
+import { TenantContextError, TenantScoped, requireTenantId, tenantId } from "@happyvertical/smrt-tenancy";
 //#region src/crm/models/Lead.ts
 var __defProp$6 = Object.defineProperty;
 var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
@@ -479,6 +479,10 @@ var __decorateClass$3 = (decorators, target, key, kind) => {
 	if (kind && result) __defProp$3(target, key, result);
 	return result;
 };
+var workflowCompletionPermits = /* @__PURE__ */ new WeakSet();
+function permitSalesActivityWorkflowCompletion(activity) {
+	workflowCompletionPermits.add(activity);
+}
 var SalesActivity = class extends SmrtObject {
 	tenantId = null;
 	/** Which model the activity attaches to: `'lead'` or `'opportunity'`. */
@@ -534,6 +538,40 @@ var SalesActivity = class extends SmrtObject {
 	setMetadata(metadata) {
 		this.metadata = JSON.stringify(metadata);
 	}
+	/**
+	* Keep Lead-task completion monotonic and service-owned even for direct
+	* model callers. The shared activity model continues to support existing
+	* opportunity and imported-history completion flows; only the Lead
+	* follow-up workflow owns its task completion transition.
+	*/
+	async save() {
+		const persisted = await this.resolvePersistedState();
+		const priorCompletedAt = persisted?.completedAt;
+		const requestedCompletedAt = this.completedAt;
+		const isNewCompletion = requestedCompletedAt !== null && (priorCompletedAt === null || priorCompletedAt === void 0);
+		if (priorCompletedAt && !sameInstant(priorCompletedAt, requestedCompletedAt)) throw new Error("SalesActivity.completedAt is monotonic and cannot be changed once set.");
+		if (persisted?.isLeadTask && !isLeadTask(this)) throw new Error("SalesActivity Lead task identity cannot be changed once persisted.");
+		if ((persisted?.isLeadTask === true || isLeadTask(this)) && isNewCompletion && !workflowCompletionPermits.has(this)) throw new Error("SalesActivity.completedAt may only be set through LeadWorkflowService.");
+		const result = await super.save();
+		workflowCompletionPermits.delete(this);
+		return result;
+	}
+	/** `undefined` means this id has not been persisted yet. */
+	async resolvePersistedState() {
+		if (!this.id) return void 0;
+		try {
+			const row = await this.db.get(this.tableName, { id: this.id });
+			if (!row) return void 0;
+			const value = row.completed_at;
+			const completedAt = value === null || value === void 0 ? null : value instanceof Date ? value : new Date(String(value));
+			return {
+				completedAt: completedAt === null || Number.isFinite(completedAt.getTime()) ? completedAt : null,
+				isLeadTask: row.subject_kind === "lead" && row.activity_kind === "task"
+			};
+		} catch {
+			return;
+		}
+	}
 };
 __decorateClass$3([tenantId({ nullable: true })], SalesActivity.prototype, "tenantId", 2);
 __decorateClass$3([field({ required: true })], SalesActivity.prototype, "subjectId", 2);
@@ -547,6 +585,12 @@ SalesActivity = __decorateClass$3([TenantScoped({ mode: "optional" }), smrt({
 	mcp: { include: ["list", "create"] },
 	cli: false
 })], SalesActivity);
+function sameInstant(expected, actual) {
+	return actual !== null && expected.getTime() === actual.getTime();
+}
+function isLeadTask(activity) {
+	return activity.subjectKind === "lead" && activity.activityKind === "task";
+}
 //#endregion
 //#region src/crm/collections/SalesActivityCollection.ts
 var SalesActivityCollection = class extends SmrtCollection {
@@ -567,9 +611,9 @@ var SalesActivityCollection = class extends SmrtCollection {
 		});
 	}
 	/**
-	* Open next actions for one subject: activities with a due date
+	* Open next actions for one subject: `task` activities with a due date
 	* (`dueAt` set) that have not been completed (`completedAt` null),
-	* soonest due first.
+	* soonest due first with a deterministic id tie-breaker.
 	*
 	* @param subjectKind - `'lead'` or `'opportunity'`
 	* @param subjectId - Subject row id
@@ -579,10 +623,11 @@ var SalesActivityCollection = class extends SmrtCollection {
 			where: {
 				subjectKind,
 				subjectId,
+				activityKind: "task",
 				"dueAt !=": null,
 				completedAt: null
 			},
-			orderBy: "due_at ASC"
+			orderBy: ["dueAt ASC", "id ASC"]
 		});
 	}
 };
@@ -1188,7 +1233,7 @@ var LeadCollection = class extends SmrtCollection {
 				subjectKind: "lead",
 				"subjectId in": Array.from(visited)
 			},
-			orderBy: "created_at ASC"
+			orderBy: ["createdAt ASC", "id ASC"]
 		});
 	}
 };
@@ -1423,6 +1468,426 @@ var SalesRepresentativeCollection = class extends SmrtCollection {
 	}
 };
 //#endregion
-export { Lead as S, SalesActivityCollection as _, LeadCollection as a, PipelineStage as b, DEFAULT_PIPELINE_STAGES as c, PIPELINE_STATUSES as d, SALES_ACTIVITY_KINDS as f, OpportunityCollection as g, PipelineDefinition as h, OpportunityConversion as i, LEAD_STATUSES as l, SALES_REPRESENTATIVE_STATUSES as m, SalesRepresentative as n, PipelineDefinitionCollection as o, SALES_ACTIVITY_SUBJECT_KINDS as p, OpportunityConversionCollection as r, DEFAULT_PIPELINE_KEY as s, SalesRepresentativeCollection as t, OPPORTUNITY_STATUSES as u, SalesActivity as v, Opportunity as x, PipelineStageCollection as y };
+//#region src/crm/services/LeadWorkflowService.ts
+var LEAD_HUMAN_ACTIVITY_KINDS = [
+	"note",
+	"call",
+	"email",
+	"meeting"
+];
+var MAX_LEAD_WORKFLOW_TEXT_LENGTH = 1e3;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+function projectLeadWorkQueue(input) {
+	const terminal = input.status === "qualified" || input.status === "merged";
+	const reopenable = input.status === "disqualified";
+	const ownerRepId = input.ownerRepId?.trim() ?? "";
+	const dueAt = input.nextAction?.dueAt ?? null;
+	const dueTime = dueAt instanceof Date ? dueAt.getTime() : NaN;
+	const now = input.now ?? /* @__PURE__ */ new Date();
+	const nowTime = now.getTime();
+	if (terminal) return queueProjection("terminal");
+	if (reopenable) return queueProjection("reopenable");
+	if (!ownerRepId) return queueProjection("unassigned");
+	if (!Number.isFinite(dueTime)) return queueProjection("no_next_action");
+	if (dueTime < nowTime) return queueProjection("overdue");
+	return queueProjection(calendarDayKey(new Date(dueTime), input.timeZone) === calendarDayKey(now, input.timeZone) ? "due_today" : "upcoming");
+}
+var LeadWorkflowValidationError = class extends Error {
+	constructor(reason, message) {
+		super(message);
+		this.reason = reason;
+		this.name = "LeadWorkflowValidationError";
+	}
+	reason;
+	code = "LEAD_WORKFLOW_VALIDATION_ERROR";
+};
+var singleConnectionMutationTails = /* @__PURE__ */ new WeakMap();
+var LeadWorkflowService = class LeadWorkflowService {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	deps;
+	static async create(options = {}) {
+		return new LeadWorkflowService({
+			leads: await LeadCollection.create(options),
+			activities: await SalesActivityCollection.create(options),
+			representatives: await SalesRepresentativeCollection.create(options)
+		});
+	}
+	/** Assign or reassign an active representative, with one audit row per change. */
+	async assignLead(input) {
+		const actorProfileId = this.requireIdentifier(input.actorProfileId, "actorProfileId");
+		const ownerRepId = this.requireIdentifier(input.ownerRepId, "ownerRepId");
+		return await this.runMutation(async (deps, tenantId) => {
+			const lead = await this.lockLead(deps, input.leadId, tenantId);
+			this.assertActiveFollowUpLead(lead);
+			const representative = await deps.representatives.get({ id: ownerRepId }, { cache: false });
+			if (!representative) throw this.refusal("representative_unavailable", "Representative is unavailable in the active tenant");
+			if (!representative.isActive()) throw this.refusal("representative_inactive", "Representative is not active");
+			if (lead.ownerRepId === ownerRepId) return {
+				lead,
+				changed: false
+			};
+			const priorOwnerRepId = lead.ownerRepId;
+			lead.ownerRepId = ownerRepId;
+			await lead.save();
+			await this.appendAudit(deps.activities, lead, {
+				actorProfileId,
+				activityKind: "assignment",
+				summary: priorOwnerRepId ? "Reassigned lead owner" : "Assigned lead owner",
+				metadata: {
+					fromOwnerRepId: priorOwnerRepId || null,
+					toOwnerRepId: ownerRepId,
+					occurredAt: this.now(input.now).toISOString()
+				}
+			});
+			return {
+				lead,
+				changed: true
+			};
+		});
+	}
+	/** Start a new Lead or reopen a disqualified Lead for active follow-up. */
+	async startWorking(input) {
+		const actorProfileId = this.requireIdentifier(input.actorProfileId, "actorProfileId");
+		return await this.runMutation(async (deps, tenantId) => {
+			const lead = await this.lockLead(deps, input.leadId, tenantId);
+			if (lead.status !== "new" && lead.status !== "disqualified") throw this.refusal("invalid_transition", `Lead cannot start working from '${lead.status}'`);
+			const from = lead.status;
+			lead.status = "working";
+			await lead.save();
+			await this.appendAudit(deps.activities, lead, {
+				actorProfileId,
+				activityKind: "status_change",
+				summary: from === "disqualified" ? "Reopened lead follow-up" : "Started lead follow-up",
+				metadata: {
+					from,
+					to: "working",
+					occurredAt: this.now(input.now).toISOString()
+				}
+			});
+			return lead;
+		});
+	}
+	/** Disqualify a new or working Lead with a required bounded rationale. */
+	async disqualifyLead(input) {
+		const actorProfileId = this.requireIdentifier(input.actorProfileId, "actorProfileId");
+		const reason = this.requireBoundedText(input.reason, "reason");
+		return await this.runMutation(async (deps, tenantId) => {
+			const lead = await this.lockLead(deps, input.leadId, tenantId);
+			if (lead.status !== "new" && lead.status !== "working") throw this.refusal("invalid_transition", `Lead cannot be disqualified from '${lead.status}'`);
+			const from = lead.status;
+			lead.status = "disqualified";
+			await lead.save();
+			await this.appendAudit(deps.activities, lead, {
+				actorProfileId,
+				activityKind: "status_change",
+				summary: "Disqualified lead",
+				metadata: {
+					from,
+					to: "disqualified",
+					reason,
+					occurredAt: this.now(input.now).toISOString()
+				}
+			});
+			return lead;
+		});
+	}
+	/** Append one immutable human note, call, email, or meeting to an active Lead. */
+	async recordActivity(input) {
+		const actorProfileId = this.requireIdentifier(input.actorProfileId, "actorProfileId");
+		const summary = this.requireBoundedText(input.summary, "summary");
+		if (!LEAD_HUMAN_ACTIVITY_KINDS.includes(input.activityKind)) throw this.refusal("invalid_activity_kind", "Activity kind is not a human follow-up activity");
+		const metadata = this.canonicalMetadata(input.metadata);
+		return await this.runMutation(async (deps, tenantId) => {
+			const lead = await this.lockLead(deps, input.leadId, tenantId);
+			this.assertActiveFollowUpLead(lead);
+			return await deps.activities.create({
+				tenantId,
+				subjectKind: "lead",
+				subjectId: this.requireLeadId(lead),
+				activityKind: input.activityKind,
+				summary,
+				actorProfileId,
+				metadata
+			});
+		});
+	}
+	/** Schedule one open `task` activity for an active Lead. */
+	async scheduleNextAction(input) {
+		const actorProfileId = this.requireIdentifier(input.actorProfileId, "actorProfileId");
+		const summary = this.requireBoundedText(input.summary, "summary");
+		const dueAt = this.requireValidDate(input.dueAt, "dueAt");
+		const metadata = this.canonicalMetadata(input.metadata);
+		return await this.runMutation(async (deps, tenantId) => {
+			const lead = await this.lockLead(deps, input.leadId, tenantId);
+			this.assertActiveFollowUpLead(lead);
+			return await deps.activities.create({
+				tenantId,
+				subjectKind: "lead",
+				subjectId: this.requireLeadId(lead),
+				activityKind: "task",
+				summary,
+				dueAt,
+				actorProfileId,
+				metadata
+			});
+		});
+	}
+	/**
+	* Complete one open lead task exactly once. The task is locked with its Lead
+	* so concurrent callers serialize; a compatible retry returns the completed
+	* task without adding a second immutable completion event.
+	*/
+	async completeNextAction(input) {
+		const actorProfileId = this.requireIdentifier(input.actorProfileId, "actorProfileId");
+		return await this.runMutation(async (deps, tenantId) => {
+			const lead = await this.lockLead(deps, input.leadId, tenantId);
+			this.assertActiveFollowUpLead(lead);
+			const task = await this.lockLeadTask(deps, input.taskId, this.requireLeadId(lead), tenantId);
+			if (task.activityKind !== "task" || !task.dueAt) throw this.refusal("task_unavailable", "Task is unavailable for this lead");
+			if (task.completedAt) {
+				if ((await this.findTaskCompletionAudit(deps.activities, this.requireLeadId(lead), this.requireActivityId(task)))?.actorProfileId === actorProfileId) return {
+					task,
+					completed: false
+				};
+				throw this.refusal("completion_replay_conflict", "Task was already completed by another actor or without compatible audit evidence");
+			}
+			const completedAt = this.now(input.now);
+			task.completedAt = completedAt;
+			permitSalesActivityWorkflowCompletion(task);
+			await task.save();
+			await this.appendAudit(deps.activities, lead, {
+				actorProfileId,
+				activityKind: "task_completion",
+				summary: `Completed next action: ${task.summary}`,
+				metadata: {
+					taskId: this.requireActivityId(task),
+					completedAt: completedAt.toISOString()
+				}
+			});
+			return {
+				task,
+				completed: true
+			};
+		});
+	}
+	/** Return a deterministic chronological activity trail across merged Lead history. */
+	async getLeadTimeline(leadId) {
+		const tenantId = this.requireActiveTenant();
+		const lead = await this.readLead(this.deps.leads, leadId, tenantId);
+		return await this.deps.leads.activitiesIncludingMerged(this.requireLeadId(lead));
+	}
+	/** Return the Lead, its visible owner, earliest open task, and queue projection. */
+	async getLeadWorkState(input) {
+		const tenantId = this.requireActiveTenant();
+		const lead = await this.readLead(this.deps.leads, input.leadId, tenantId);
+		const leadId = this.requireLeadId(lead);
+		const [owner, openTasks] = await Promise.all([lead.ownerRepId ? this.deps.representatives.get({ id: lead.ownerRepId }, { cache: false }) : Promise.resolve(null), this.deps.activities.findOpenTasks("lead", leadId)]);
+		const earliestOpenTask = openTasks[0] ?? null;
+		return {
+			lead,
+			owner,
+			earliestOpenTask,
+			queue: projectLeadWorkQueue({
+				status: lead.status,
+				ownerRepId: lead.ownerRepId,
+				nextAction: earliestOpenTask,
+				now: input.now,
+				timeZone: input.timeZone
+			})
+		};
+	}
+	async runMutation(fn) {
+		const tenantId = this.requireActiveTenant();
+		const db = this.deps.leads.db;
+		if (typeof db.transaction !== "function") throw this.refusal("transaction_unavailable", "Lead workflow mutations require a transaction-capable database adapter");
+		const transaction = db.transaction.bind(db);
+		const supportsRowLocks = this.supportsRowLocks(db);
+		const runTransaction = async () => await transaction(async (tx) => fn({
+			leads: await LeadCollection.create({
+				db: tx,
+				_reuseInitializedDb: true,
+				_deferRuntimeInitialization: true
+			}),
+			activities: await SalesActivityCollection.create({
+				db: tx,
+				_reuseInitializedDb: true,
+				_deferRuntimeInitialization: true
+			}),
+			representatives: await SalesRepresentativeCollection.create({
+				db: tx,
+				_reuseInitializedDb: true,
+				_deferRuntimeInitialization: true
+			}),
+			supportsRowLocks
+		}, tenantId));
+		if (supportsRowLocks) return await runTransaction();
+		const turn = (singleConnectionMutationTails.get(db) ?? Promise.resolve()).then(runTransaction, runTransaction);
+		singleConnectionMutationTails.set(db, turn.then(() => void 0, () => void 0));
+		return await turn;
+	}
+	/** PostgreSQL gets a row lock; other adapters are serialized by runMutation. */
+	async lockLead(deps, leadId, tenantId) {
+		if (!UUID_RE.test(leadId)) throw this.refusal("lead_unavailable", "Lead is unavailable in the active tenant");
+		if (deps.supportsRowLocks) {
+			const lead = (await deps.leads.query(`SELECT * FROM ${deps.leads.tableName}
+         WHERE id = $1 AND tenant_id = $2
+         FOR UPDATE`, [leadId, tenantId], { allowRawOnTenantScoped: true }))[0];
+			if (lead && lead.tenantId === tenantId) return lead;
+			throw this.refusal("lead_unavailable", "Lead is unavailable in the active tenant");
+		}
+		return await this.readLead(deps.leads, leadId, tenantId);
+	}
+	async lockLeadTask(deps, taskId, leadId, tenantId) {
+		if (!UUID_RE.test(taskId)) throw this.refusal("task_unavailable", "Task is unavailable for this lead");
+		if (deps.supportsRowLocks) {
+			const task2 = (await deps.activities.query(`SELECT * FROM ${deps.activities.tableName}
+         WHERE id = $1
+           AND subject_kind = 'lead'
+           AND subject_id = $2
+           AND tenant_id = $3
+         FOR UPDATE`, [
+				taskId,
+				leadId,
+				tenantId
+			], { allowRawOnTenantScoped: true }))[0];
+			if (task2 && task2.tenantId === tenantId) return task2;
+			throw this.refusal("task_unavailable", "Task is unavailable for this lead");
+		}
+		const task = await deps.activities.get({ id: taskId }, { cache: false });
+		if (!task || task.tenantId !== tenantId || task.subjectKind !== "lead" || task.subjectId !== leadId) throw this.refusal("task_unavailable", "Task is unavailable for this lead");
+		return task;
+	}
+	async readLead(leads, leadId, tenantId) {
+		if (!UUID_RE.test(leadId)) throw this.refusal("lead_unavailable", "Lead is unavailable in the active tenant");
+		const lead = await leads.get({ id: leadId }, { cache: false });
+		if (!lead || lead.tenantId !== tenantId) throw this.refusal("lead_unavailable", "Lead is unavailable in the active tenant");
+		return lead;
+	}
+	assertActiveFollowUpLead(lead) {
+		if (lead.status !== "new" && lead.status !== "working") throw this.refusal("lead_not_actionable", `Lead is not actionable for ordinary follow-up while '${lead.status}'`);
+	}
+	async appendAudit(activities, lead, input) {
+		return await activities.create({
+			tenantId: lead.tenantId,
+			subjectKind: "lead",
+			subjectId: this.requireLeadId(lead),
+			activityKind: input.activityKind,
+			summary: input.summary,
+			actorProfileId: input.actorProfileId,
+			metadata: JSON.stringify(input.metadata)
+		});
+	}
+	async findTaskCompletionAudit(activities, leadId, taskId) {
+		return (await activities.findBySubject("lead", leadId)).find((candidate) => candidate.activityKind === "task_completion" && candidate.getMetadata().taskId === taskId) ?? null;
+	}
+	requireActiveTenant() {
+		try {
+			return requireTenantId();
+		} catch (error) {
+			if (!(error instanceof TenantContextError)) throw error;
+			throw this.refusal("tenant_context_required", "Lead workflow operations require an active tenant context");
+		}
+	}
+	canonicalMetadata(metadata) {
+		const value = metadata ?? {};
+		if (!isPlainJsonObject(value) || !isJsonValue(value, /* @__PURE__ */ new Set())) throw this.refusal("invalid_metadata", "Activity metadata must be a plain JSON object with JSON values");
+		return JSON.stringify(value);
+	}
+	requireBoundedText(value, field) {
+		const normalized = typeof value === "string" ? value.trim() : "";
+		if (!normalized) throw this.refusal(field === "summary" ? "summary_required" : "reason_required", `Lead workflow ${field} is required`);
+		if (normalized.length > 1e3) throw this.refusal(field === "summary" ? "summary_too_long" : "reason_too_long", `Lead workflow ${field} must be at most ${MAX_LEAD_WORKFLOW_TEXT_LENGTH} characters`);
+		return normalized;
+	}
+	requireIdentifier(value, field) {
+		const normalized = typeof value === "string" ? value.trim() : "";
+		if (!normalized || (field === "ownerRepId" || field === "actorProfileId") && !UUID_RE.test(normalized)) throw this.refusal(field === "ownerRepId" ? "representative_unavailable" : "invalid_metadata", `Lead workflow ${field} must be a UUID`);
+		return normalized;
+	}
+	requireValidDate(value, field) {
+		if (!(value instanceof Date) || !Number.isFinite(value.getTime())) throw this.refusal("invalid_due_at", `Lead workflow ${field} must be a valid date`);
+		return value;
+	}
+	requireLeadId(lead) {
+		if (!lead.id) throw this.refusal("lead_unavailable", "Lead is unavailable in the active tenant");
+		return lead.id;
+	}
+	requireActivityId(activity) {
+		if (!activity.id) throw this.refusal("task_unavailable", "Task is unavailable for this lead");
+		return activity.id;
+	}
+	now(value) {
+		return value ?? /* @__PURE__ */ new Date();
+	}
+	supportsRowLocks(db) {
+		return typeof db.acquireSession === "function";
+	}
+	refusal(reason, message) {
+		return new LeadWorkflowValidationError(reason, message);
+	}
+};
+function queueProjection(state) {
+	return {
+		state,
+		isActionable: state === "unassigned" || state === "no_next_action" || state === "overdue" || state === "due_today" || state === "upcoming",
+		isUnassigned: state === "unassigned",
+		hasNoNextAction: state === "no_next_action",
+		isOverdue: state === "overdue",
+		isDueToday: state === "due_today",
+		isUpcoming: state === "upcoming",
+		isTerminal: state === "terminal",
+		isReopenable: state === "reopenable"
+	};
+}
+function calendarDayKey(date, timeZone) {
+	const options = {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit"
+	};
+	let formatter;
+	try {
+		formatter = new Intl.DateTimeFormat("en-US", {
+			...options,
+			timeZone
+		});
+	} catch {
+		formatter = new Intl.DateTimeFormat("en-US", options);
+	}
+	const parts = formatter.formatToParts(date);
+	const get = (type) => parts.find((part) => part.type === type)?.value ?? "";
+	return `${get("year")}-${get("month")}-${get("day")}`;
+}
+function isPlainJsonObject(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function isJsonValue(value, ancestors) {
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return true;
+	if (Array.isArray(value)) {
+		if (ancestors.has(value)) return false;
+		ancestors.add(value);
+		try {
+			return value.every((item) => isJsonValue(item, ancestors));
+		} finally {
+			ancestors.delete(value);
+		}
+	}
+	if (isPlainJsonObject(value)) {
+		if (ancestors.has(value)) return false;
+		ancestors.add(value);
+		try {
+			return Object.values(value).every((item) => isJsonValue(item, ancestors));
+		} finally {
+			ancestors.delete(value);
+		}
+	}
+	return false;
+}
+//#endregion
+export { SalesActivity as C, Lead as D, Opportunity as E, SalesActivityCollection as S, PipelineStage as T, SALES_ACTIVITY_KINDS as _, projectLeadWorkQueue as a, PipelineDefinition as b, OpportunityConversionCollection as c, PipelineDefinitionCollection as d, DEFAULT_PIPELINE_KEY as f, PIPELINE_STATUSES as g, OPPORTUNITY_STATUSES as h, MAX_LEAD_WORKFLOW_TEXT_LENGTH as i, OpportunityConversion as l, LEAD_STATUSES as m, LeadWorkflowService as n, SalesRepresentativeCollection as o, DEFAULT_PIPELINE_STAGES as p, LeadWorkflowValidationError as r, SalesRepresentative as s, LEAD_HUMAN_ACTIVITY_KINDS as t, LeadCollection as u, SALES_ACTIVITY_SUBJECT_KINDS as v, PipelineStageCollection as w, OpportunityCollection as x, SALES_REPRESENTATIVE_STATUSES as y };
 
-//# sourceMappingURL=crm-DwEz7E2r.js.map
+//# sourceMappingURL=crm-B8XqwUBg.js.map