@happyvertical/smrt-sales 0.57.2 → 0.57.3

package/dist/chunks/{agreements-BB_tNU0U.js → agreements-jBiVmttD.js}

@@ -1,7 +1,14 @@
-import { SmrtCollection, SmrtObject, crossPackageRef, field, foreignKey, smrt } from "@happyvertical/smrt-core";
-import { TenantScoped, requireTenantId, tenantId } from "@happyvertical/smrt-tenancy";
+import { SmrtCollection, SmrtObject, crossPackageRef, field, foreignKey, invalidateCollectionCache, isEmbeddedDatabase, isPostgresDatabase, resolveDbCacheKey, smrt, withEmbeddedWriteTransaction } from "@happyvertical/smrt-core";
+import { TenantScoped, assertTenantReadAllowed, getCurrentTenant, requireTenantId, tenantId } from "@happyvertical/smrt-tenancy";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/agreements/types.ts
+var AGREEMENT_STATUSES = [
+	"draft",
+	"cancelled",
+	"active",
+	"superseded",
+	"terminated"
+];
 var AGREEMENT_EXECUTION_STATUSES = [
 	"prepared",
 	"sent",
@@ -46,6 +53,445 @@ function coerceAgreementDate(value) {
 	return null;
 }
 //#endregion
+//#region src/agreements/models/Agreement.ts
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$3(target, key, result);
+	return result;
+};
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var STATUS_TRANSITIONS = {
+	draft: ["active", "cancelled"],
+	cancelled: [],
+	active: ["superseded", "terminated"],
+	superseded: [],
+	terminated: []
+};
+var loadedStatus = /* @__PURE__ */ new WeakMap();
+var frozenTerms = /* @__PURE__ */ new WeakMap();
+var frozenEnd = /* @__PURE__ */ new WeakMap();
+function serializeAgreementParty(party) {
+	if (!party || typeof party !== "object" || typeof party.kind !== "string" || !party.kind.trim() || typeof party.id !== "string" || !party.id.trim()) throw new Error("Agreement party requires non-empty kind and id");
+	return JSON.stringify({
+		kind: party.kind,
+		id: party.id
+	});
+}
+function parseAgreementParty(value) {
+	try {
+		const parsed = JSON.parse(value);
+		if (parsed && typeof parsed === "object" && typeof parsed.kind === "string" && parsed.kind.trim() && typeof parsed.id === "string" && parsed.id.trim()) return {
+			kind: parsed.kind,
+			id: parsed.id
+		};
+	} catch {}
+	return null;
+}
+var Agreement = class extends SmrtObject {
+	tenantId = null;
+	kind = "";
+	partyA = "";
+	partyB = "";
+	/** Monotonic version within tenant, kind, and ordered counterparties. */
+	version = 1;
+	status = "draft";
+	/** JSON object containing consumer-defined, frozen commercial terms. */
+	terms = "{}";
+	/** Inclusive start of the effective interval; null means no lower bound. */
+	effectiveFrom = null;
+	/**
+	* Exclusive end of the effective interval; null means no upper bound.
+	* It is the one lifecycle-derived field: `AgreementCollection.activateAmendment`
+	* closes a predecessor at the new version's start in the same transition.
+	*/
+	effectiveTo = null;
+	executedAgreementId = null;
+	amendmentPredecessorId = null;
+	amendmentPredecessorEnd = null;
+	metadata = "{}";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.kind !== void 0) this.kind = options.kind;
+		if (options.partyA !== void 0) this.partyA = options.partyA;
+		if (options.partyB !== void 0) this.partyB = options.partyB;
+		if (options.version !== void 0) this.version = options.version;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.terms !== void 0) this.terms = options.terms;
+		if (options.effectiveFrom !== void 0) this.effectiveFrom = coerceAgreementDate(options.effectiveFrom);
+		if (options.effectiveTo !== void 0) this.effectiveTo = coerceAgreementDate(options.effectiveTo);
+		if (options.executedAgreementId !== void 0) this.executedAgreementId = options.executedAgreementId;
+		if (options.amendmentPredecessorId !== void 0) this.amendmentPredecessorId = options.amendmentPredecessorId;
+		if (options.amendmentPredecessorEnd !== void 0) this.amendmentPredecessorEnd = coerceAgreementDate(options.amendmentPredecessorEnd);
+		if (options.metadata !== void 0) this.metadata = options.metadata;
+	}
+	async initialize() {
+		await super.initialize();
+		this.effectiveFrom = coerceAgreementDate(this.effectiveFrom);
+		this.effectiveTo = coerceAgreementDate(this.effectiveTo);
+		this.amendmentPredecessorEnd = coerceAgreementDate(this.amendmentPredecessorEnd);
+		if (this.isPersisted) {
+			loadedStatus.set(this, this.status);
+			if (this.status !== "draft") {
+				frozenTerms.set(this, this.serializeFrozenTerms());
+				frozenEnd.set(this, this.effectiveTo?.getTime() ?? null);
+			}
+		}
+		return this;
+	}
+	isDraft() {
+		return this.status === "draft";
+	}
+	isActive() {
+		return this.status === "active";
+	}
+	/**
+	* Tests the half-open effective interval `[effectiveFrom, effectiveTo)`.
+	* This makes an amendment starting at `T` and its predecessor ending at
+	* `T` non-overlapping. Lifecycle status is intentionally not considered.
+	*/
+	isEffectiveAt(at) {
+		return !(this.effectiveFrom && at < this.effectiveFrom || this.effectiveTo && at >= this.effectiveTo);
+	}
+	getPartyA() {
+		return parseAgreementParty(this.partyA);
+	}
+	getPartyB() {
+		return parseAgreementParty(this.partyB);
+	}
+	setPartyA(party) {
+		this.partyA = serializeAgreementParty(party);
+	}
+	setPartyB(party) {
+		this.partyB = serializeAgreementParty(party);
+	}
+	getTerms() {
+		return parseObject(this.terms) ?? {};
+	}
+	setTerms(terms) {
+		if (!terms || typeof terms !== "object" || Array.isArray(terms)) throw new Error("Agreement terms must be a JSON object");
+		this.terms = JSON.stringify(terms);
+	}
+	activate() {
+		if (this.status !== "draft") throw new Error(`Agreement: cannot activate from status '${this.status}'`);
+		this.assertValidTerms();
+		this.status = "active";
+	}
+	supersede() {
+		if (this.status !== "active") throw new Error(`Agreement: cannot supersede from status '${this.status}'`);
+		if (!this.effectiveTo) throw new Error("Agreement supersession requires an effective end boundary");
+		this.assertValidTerms();
+		this.status = "superseded";
+	}
+	terminate(at = /* @__PURE__ */ new Date()) {
+		if (this.status !== "draft" && this.status !== "active") throw new Error(`Agreement: cannot terminate from status '${this.status}'`);
+		if (this.status === "active" && (!this.effectiveTo || this.effectiveTo > at)) this.effectiveTo = at;
+		this.status = this.status === "draft" ? "cancelled" : "terminated";
+	}
+	async save() {
+		const partyA = this.getPartyA();
+		const partyB = this.getPartyB();
+		if (partyA) this.partyA = serializeAgreementParty(partyA);
+		if (partyB) this.partyB = serializeAgreementParty(partyB);
+		await this.assertActivationProvenanceUnchanged();
+		const prior = await this.resolvePriorStatus();
+		this.assertStatusTransition(prior);
+		this.assertEffectiveIntervalUnchanged(prior);
+		this.assertFrozenTermsUnchanged();
+		await this.assertNaturalKeyNotTaken();
+		if (this.status !== "draft" && this.status !== "cancelled") this.assertValidTerms();
+		if (!this.isPersisted) this.requireInsertOnSave();
+		const result = await super.save();
+		loadedStatus.set(this, this.status);
+		if (this.status !== "draft" && !frozenTerms.has(this)) frozenTerms.set(this, this.serializeFrozenTerms());
+		if (this.status !== "draft") frozenEnd.set(this, this.effectiveTo?.getTime() ?? null);
+		return result;
+	}
+	/** @internal Complete observation of a collection-owned guarded transition. */
+	async refreshAfterLifecycleTransition() {
+		if (!this.isPersisted || !this.id) throw new Error("Agreement is not persisted");
+		const durableRow = await this.db.get(this.tableName, { id: this.id });
+		if (!durableRow) throw new Error("Agreement disappeared during transition");
+		await this.completePersistedUpdate(durableRow);
+		loadedStatus.set(this, this.status);
+		frozenTerms.set(this, this.serializeFrozenTerms());
+		frozenEnd.set(this, this.effectiveTo?.getTime() ?? null);
+	}
+	async assertActivationProvenanceUnchanged() {
+		const persisted = this.isPersisted && this.id ? await this.db.get(this.tableName, { id: this.id }) : null;
+		const priorId = persisted?.amendment_predecessor_id ?? null;
+		const priorEnd = coerceAgreementDate(persisted?.amendment_predecessor_end)?.getTime() ?? null;
+		if (this.amendmentPredecessorId !== priorId || (this.amendmentPredecessorEnd?.getTime() ?? null) !== priorEnd) throw new Error("Agreement activation provenance is owned by activateAmendment");
+	}
+	assertEffectiveIntervalUnchanged(prior) {
+		const captured = frozenEnd.get(this);
+		const current = this.effectiveTo?.getTime() ?? null;
+		if (captured === void 0 || captured === current) return;
+		if (!(prior === "active" && (this.status === "superseded" || this.status === "terminated")) || current === null || captured !== null && current > captured) throw new Error("Agreement effective interval is immutable except for lifecycle closure");
+	}
+	assertValidTerms() {
+		if (this.status === "superseded" && !this.effectiveTo) throw new Error("Agreement supersession requires an effective end boundary");
+		if (!this.kind.trim()) throw new Error("Agreement kind is required");
+		if (!parseAgreementParty(this.partyA) || !parseAgreementParty(this.partyB)) throw new Error("Agreement requires valid partyA and partyB descriptors");
+		if (!parseObject(this.terms)) throw new Error("Agreement terms must be a JSON object");
+		if (!Number.isSafeInteger(this.version) || this.version < 1) throw new Error("Agreement version must be a positive integer");
+		if (this.effectiveFrom && this.effectiveTo && this.effectiveTo <= this.effectiveFrom) throw new Error("Agreement effectiveTo must be after effectiveFrom");
+	}
+	async assertNaturalKeyNotTaken() {
+		if (!this.kind || !this.partyA || !this.partyB) return;
+		try {
+			const res = await this.db.query(`SELECT id, tenant_id FROM ${this.tableName} WHERE kind = $1 AND party_a = $2 AND party_b = $3 AND version = $4`, this.kind, this.partyA, this.partyB, this.version);
+			if ((Array.isArray(res) ? res : res.rows ?? []).some((row) => (row.tenant_id ?? null) === (this.tenantId ?? null) && row.id !== this.id)) throw new Error(`Agreement ${this.kind}@${this.version}: this immutable version already exists; create an amendment instead`);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("immutable version")) throw error;
+		}
+	}
+	async resolvePriorStatus() {
+		if (this.id) try {
+			const row = await this.db.get(this.tableName, { id: this.id });
+			if (row?.status != null) return row.status;
+		} catch {}
+		return loadedStatus.get(this);
+	}
+	assertStatusTransition(prior) {
+		if (prior === void 0 || prior === this.status) return;
+		if (!(STATUS_TRANSITIONS[prior] ?? []).includes(this.status)) throw new Error(`Agreement: illegal status transition '${prior}' \u2192 '${this.status}'`);
+	}
+	assertFrozenTermsUnchanged() {
+		const captured = frozenTerms.get(this);
+		if (captured && captured !== this.serializeFrozenTerms()) throw new Error("Agreement terms are immutable once active; create an amendment instead");
+	}
+	serializeFrozenTerms() {
+		return JSON.stringify({
+			kind: this.kind,
+			partyA: this.partyA,
+			partyB: this.partyB,
+			version: this.version,
+			terms: this.terms,
+			effectiveFrom: this.effectiveFrom?.toISOString() ?? null,
+			executedAgreementId: this.executedAgreementId,
+			amendmentPredecessorId: this.amendmentPredecessorId,
+			amendmentPredecessorEnd: this.amendmentPredecessorEnd?.toISOString() ?? null
+		});
+	}
+};
+__publicField$3(Agreement, "__smrtPackage__", "@happyvertical/smrt-sales");
+__decorateClass$3([tenantId({ nullable: true })], Agreement.prototype, "tenantId", 2);
+__decorateClass$3([field({ required: true })], Agreement.prototype, "kind", 2);
+__decorateClass$3([field({ required: true })], Agreement.prototype, "partyA", 2);
+__decorateClass$3([field({ required: true })], Agreement.prototype, "partyB", 2);
+__decorateClass$3([foreignKey("ExecutedAgreement")], Agreement.prototype, "executedAgreementId", 2);
+__decorateClass$3([foreignKey("Agreement")], Agreement.prototype, "amendmentPredecessorId", 2);
+Agreement = __decorateClass$3([TenantScoped({ mode: "optional" }), smrt({
+	conflictColumns: [
+		"tenant_id",
+		"kind",
+		"party_a",
+		"party_b",
+		"version"
+	],
+	api: { include: [
+		"list",
+		"get",
+		"create"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: { skipApiCheck: true }
+})], Agreement);
+function parseObject(value) {
+	try {
+		const parsed = JSON.parse(value);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/agreements/collections/AgreementCollection.ts
+var AgreementCollection = class AgreementCollection extends SmrtCollection {
+	static _itemClass = Agreement;
+	async findVersions(kind, partyA, partyB) {
+		return await this.findGoverningCandidates(kind, serializeAgreementParty(partyA), serializeAgreementParty(partyB), this.ambientTenantId());
+	}
+	/**
+	* Resolves the sole version governing `at`. This is a historical query:
+	* a superseded or terminated row can still govern before its exclusive
+	* `effectiveTo`; today's lifecycle status alone is never used to answer a
+	* record-date lookup. Drafts never govern.
+	*
+	* Generated amendments are non-overlapping because the predecessor ends at
+	* the successor's inclusive start. If imported or manually-created rows do
+	* overlap, this helper throws instead of silently selecting a version.
+	*/
+	async activeFor(kind, partyA, partyB, at = /* @__PURE__ */ new Date(), tenantId) {
+		const partyAValue = serializeAgreementParty(partyA);
+		const partyBValue = serializeAgreementParty(partyB);
+		const lane = tenantId === void 0 ? this.ambientTenantId() : tenantId;
+		const governs = (agreement) => agreement.status !== "draft" && agreement.status !== "cancelled" && agreement.isEffectiveAt(at);
+		const candidates = await this.findGoverningCandidates(kind, partyAValue, partyBValue, lane, false);
+		let matches = candidates.filter(governs);
+		const laneHasBegun = candidates.some((agreement) => agreement.status !== "draft" && agreement.status !== "cancelled" && (!agreement.effectiveFrom || agreement.effectiveFrom <= at));
+		if (matches.length === 0 && lane != null && !laneHasBegun) matches = (await this.findGoverningCandidates(kind, partyAValue, partyBValue, null, false)).filter(governs);
+		if (matches.length > 1) throw new Error(`Agreement overlap for '${kind}' parties at ${at.toISOString()}; resolve the conflicting effective intervals before using these terms`);
+		return matches[0] ?? null;
+	}
+	/** Creates the next unsigned/draft version without changing prior history. */
+	async createAmendment(kind, partyA, partyB, changes = {}) {
+		const createdId = await this.runTransaction(async (agreements) => {
+			let versions = await agreements.findVersions(kind, partyA, partyB);
+			if (!versions.length) throw new Error(`AgreementCollection.createAmendment: no versions exist for '${kind}' parties \u2014 create the initial agreement first`);
+			if (versions[0].tenantId !== (this.ambientTenantId() ?? null)) throw new Error("Create an initial tenant agreement before amending global terms");
+			if (isPostgresDatabase(this.db)) {
+				const anchor = versions[versions.length - 1];
+				await agreements.db.query(`SELECT id FROM ${agreements.tableName} WHERE id = $1 FOR UPDATE`, anchor.id);
+				versions = await agreements.findVersions(kind, partyA, partyB);
+			}
+			const latest = versions[0];
+			if (changes.terms !== void 0 && Array.isArray(changes.terms)) throw new Error("Agreement amendment terms must be a JSON object");
+			return (await agreements.create({
+				tenantId: latest.tenantId,
+				kind,
+				partyA: serializeAgreementParty(partyA),
+				partyB: serializeAgreementParty(partyB),
+				version: latest.version + 1,
+				status: "draft",
+				terms: changes.terms !== void 0 ? JSON.stringify(changes.terms) : latest.terms,
+				effectiveFrom: changes.effectiveFrom !== void 0 ? changes.effectiveFrom : latest.effectiveFrom,
+				effectiveTo: changes.effectiveTo !== void 0 ? changes.effectiveTo : latest.effectiveTo,
+				executedAgreementId: changes.executedAgreementId ?? null,
+				metadata: changes.metadata !== void 0 ? JSON.stringify(changes.metadata) : latest.metadata
+			})).id;
+		});
+		invalidateCollectionCache(resolveDbCacheKey(this.db), this.tableName);
+		const created = await this.get({ id: createdId });
+		if (!created) throw new Error(`Agreement '${createdId}' disappeared`);
+		return created;
+	}
+	/**
+	* Activates an amendment and closes any currently governing predecessor at
+	* the new version's start. The interval is `[from, to)`, so equal boundary
+	* timestamps do not overlap. A future-dated amendment may be activated in
+	* advance; record-date lookup still selects its predecessor until `from`.
+	*/
+	async activateAmendment(id) {
+		const activatedId = await this.runTransaction(async (agreements) => {
+			const draft = await agreements.get({ id });
+			if (!draft) throw new Error(`Agreement '${id}' was not found`);
+			if (!draft.isDraft()) throw new Error("Only a draft Agreement amendment can be activated");
+			if (!draft.effectiveFrom) throw new Error("Agreement amendment requires effectiveFrom");
+			const partyA = draft.getPartyA();
+			const partyB = draft.getPartyB();
+			if (!partyA || !partyB) throw new Error("Agreement has invalid parties");
+			const versions = await agreements.findGoverningCandidates(draft.kind, serializeAgreementParty(partyA), serializeAgreementParty(partyB), draft.tenantId, false);
+			const predecessors = versions.filter((version) => version.id !== draft.id && version.status === "active" && version.version < draft.version && version.isEffectiveAt(draft.effectiveFrom));
+			if (predecessors.length > 1) throw new Error("Agreement amendment has overlapping active predecessors");
+			const predecessor = predecessors[0];
+			if (versions.some((version) => {
+				if (version.id === draft.id || version.id === predecessor?.id || version.status === "draft" || version.status === "cancelled") return false;
+				return (!draft.effectiveTo || !version.effectiveFrom || version.effectiveFrom < draft.effectiveTo) && (!version.effectiveTo || version.effectiveTo > draft.effectiveFrom);
+			})) throw new Error("Agreement amendment would overlap governing history");
+			if (predecessor?.effectiveFrom && predecessor.effectiveFrom >= draft.effectiveFrom) throw new Error("Agreement amendment would overlap the predecessor start");
+			const originalEnd = predecessor?.effectiveTo ?? null;
+			if (predecessor) {
+				predecessor.effectiveTo = draft.effectiveFrom;
+				predecessor.supersede();
+				await predecessor.save();
+			}
+			draft.activate();
+			await draft.save();
+			if (predecessor) {
+				await claimLifecycleRevision(draft);
+				if (returnedRows(await agreements.db.query(`UPDATE ${agreements.tableName} SET amendment_predecessor_id = $1, amendment_predecessor_end = $2 WHERE id = $3 AND status = 'active' RETURNING id`, predecessor.id, originalEnd?.toISOString() ?? null, draft.id)).length !== 1) throw new Error("Agreement activation changed concurrently");
+				await draft.refreshAfterLifecycleTransition();
+			}
+			return draft.id;
+		});
+		invalidateCollectionCache(resolveDbCacheKey(this.db), this.tableName);
+		const activated = await this.get({ id: activatedId });
+		if (!activated) throw new Error(`Agreement '${activatedId}' disappeared`);
+		return activated;
+	}
+	/** Withdraw a scheduled successor before it has ever governed.
+	* Restores only its persisted predecessor boundary, in the same transaction.
+	* Repeated/concurrent withdrawal refuses rather than applying recovery twice.
+	*/
+	async withdrawAmendment(id) {
+		const db = this.db;
+		if (typeof db.transaction !== "function") throw new Error("Agreement withdrawal requires transaction support");
+		await withEmbeddedWriteTransaction(db, isEmbeddedDatabase(db), async (tx) => {
+			const agreements = await AgreementCollection.create({ db: tx });
+			const successor = await agreements.get({ id });
+			const now = /* @__PURE__ */ new Date();
+			if (!successor || successor.status !== "active" || !successor.effectiveFrom || successor.effectiveFrom <= now || !successor.amendmentPredecessorId) throw new Error("Only a scheduled active amendment with predecessor provenance can be withdrawn");
+			const predecessor = await agreements.get({ id: successor.amendmentPredecessorId });
+			if (!predecessor || predecessor.tenantId !== successor.tenantId || predecessor.kind !== successor.kind || predecessor.partyA !== successor.partyA || predecessor.partyB !== successor.partyB || predecessor.version >= successor.version || predecessor.status !== "superseded" || predecessor.effectiveTo?.getTime() !== successor.effectiveFrom.getTime()) throw new Error("Agreement withdrawal predecessor no longer matches activation provenance");
+			const restoredEnd = successor.amendmentPredecessorEnd;
+			if (restoredEnd && restoredEnd <= successor.effectiveFrom) throw new Error("Agreement withdrawal has invalid predecessor boundary provenance");
+			if ((await agreements.findGoverningCandidates(successor.kind, successor.partyA, successor.partyB, successor.tenantId, false)).some((row) => row.id !== successor.id && row.id !== predecessor.id && row.status !== "draft" && row.status !== "cancelled" && (!restoredEnd || !row.effectiveFrom || row.effectiveFrom < restoredEnd) && (!row.effectiveTo || row.effectiveTo > successor.effectiveFrom))) throw new Error("Agreement withdrawal would overlap governing history");
+			await claimLifecycleRevision(successor);
+			if (returnedRows(await tx.query(`UPDATE ${agreements.tableName} SET status = 'cancelled' WHERE id = $1 AND status = 'active' AND effective_from > $2 RETURNING id`, id, (/* @__PURE__ */ new Date()).toISOString())).length !== 1) throw new Error("Agreement withdrawal lost its scheduled active transition");
+			await claimLifecycleRevision(predecessor);
+			if (returnedRows(await tx.query(`UPDATE ${agreements.tableName} SET status = 'active', effective_to = $1 WHERE id = $2 AND status = 'superseded' AND effective_to = $3 RETURNING id`, restoredEnd?.toISOString() ?? null, predecessor.id, successor.effectiveFrom.toISOString())).length !== 1) throw new Error("Agreement withdrawal predecessor changed concurrently");
+			await successor.refreshAfterLifecycleTransition();
+			await predecessor.refreshAfterLifecycleTransition();
+		});
+		invalidateCollectionCache(resolveDbCacheKey(this.db), this.tableName);
+		const withdrawn = await this.get({ id });
+		if (!withdrawn) throw new Error(`Agreement '${id}' disappeared`);
+		return withdrawn;
+	}
+	async findGoverningCandidates(kind, partyA, partyB, tenantId, includeGlobalFallback = true) {
+		if (tenantId === null) return await this.query(`SELECT * FROM ${this.tableName} WHERE tenant_id IS NULL AND kind = ? AND party_a = ? AND party_b = ? ORDER BY version DESC`, [
+			kind,
+			partyA,
+			partyB
+		], { allowRawOnTenantScoped: true });
+		if (tenantId === void 0) return await this.query(`SELECT * FROM ${this.tableName} WHERE tenant_id IS NULL AND kind = ? AND party_a = ? AND party_b = ? ORDER BY version DESC`, [
+			kind,
+			partyA,
+			partyB
+		], { allowRawOnTenantScoped: true });
+		assertTenantReadAllowed(tenantId, "AgreementCollection.activeFor");
+		const tenantRows = await this.query(`SELECT * FROM ${this.tableName} WHERE tenant_id = ? AND kind = ? AND party_a = ? AND party_b = ? ORDER BY version DESC`, [
+			tenantId,
+			kind,
+			partyA,
+			partyB
+		], { allowRawOnTenantScoped: true });
+		if (tenantRows.length > 0 || !includeGlobalFallback) return tenantRows;
+		return await this.query(`SELECT * FROM ${this.tableName} WHERE tenant_id IS NULL AND kind = ? AND party_a = ? AND party_b = ? ORDER BY version DESC`, [
+			kind,
+			partyA,
+			partyB
+		], { allowRawOnTenantScoped: true });
+	}
+	ambientTenantId() {
+		return getCurrentTenant()?.tenantId;
+	}
+	async runTransaction(fn) {
+		const db = this.db;
+		if (typeof db.transaction !== "function") throw new Error("Agreement amendment activation requires transaction support");
+		return await withEmbeddedWriteTransaction(db, isEmbeddedDatabase(db), async (tx) => fn(await AgreementCollection.create({ db: tx })));
+	}
+};
+function returnedRows(result) {
+	if (Array.isArray(result)) return result;
+	return result?.rows ?? [];
+}
+async function claimLifecycleRevision(agreement) {
+	if (!agreement.updated_at) throw new Error("Agreement has no persisted revision");
+	await agreement.claimRevision(agreement.updated_at);
+}
+//#endregion
 //#region src/agreements/models/AgreementExecution.ts
 var __defProp$2 = Object.defineProperty;
 var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
@@ -1659,6 +2105,6 @@ function canAdvanceStatus(current, next) {
 	return (STATUS_PROGRESS.get(next) ?? -1) >= (STATUS_PROGRESS.get(current) ?? -1);
 }
 //#endregion
-export { AgreementExecutionEvent as a, AGREEMENT_EXECUTION_STATUSES as c, sanitizeSignerIntent as d, AgreementExecutionEventCollection as i, coerceAgreementDate as l, ExecutedAgreementCollection as n, AgreementExecutionCollection as o, ExecutedAgreement as r, AgreementExecution as s, AgreementExecutionService as t, sanitizeSignerEvidence as u };
+export { AgreementExecutionEvent as a, AgreementCollection as c, serializeAgreementParty as d, AGREEMENT_EXECUTION_STATUSES as f, sanitizeSignerIntent as g, sanitizeSignerEvidence as h, AgreementExecutionEventCollection as i, Agreement as l, coerceAgreementDate as m, ExecutedAgreementCollection as n, AgreementExecutionCollection as o, AGREEMENT_STATUSES as p, ExecutedAgreement as r, AgreementExecution as s, AgreementExecutionService as t, parseAgreementParty as u };
 
-//# sourceMappingURL=agreements-BB_tNU0U.js.map
+//# sourceMappingURL=agreements-jBiVmttD.js.map