@happyvertical/smrt-profiles 0.39.13 → 0.39.15

package/dist/chunks/ProfileCollection-Bix9yAiy.js

@@ -0,0 +1,1161 @@
+import { y as __exportAll } from "./NostrIdentity-DF_a_WZk.js";
+import { SmrtCollection, SmrtObject, ValidationError, field, foreignKey, oneToMany, smrt } from "@happyvertical/smrt-core";
+import { definePrompt, resolvePrompt } from "@happyvertical/smrt-prompts";
+import { TenantScoped, queryGlobal, queryWithGlobals, tenantId, withSystemContext } from "@happyvertical/smrt-tenancy";
+import { BackfillTableUnavailableError, BackfillTracker } from "@happyvertical/smrt-core/migrations";
+import { addOwnedAssetFromCollection, assertValidOwnedAssetRelationship, assertValidOwnedAssetSortOrder, getOwnedAssetsFromCollection, removeOwnedAssetFromCollection, resolveOwnedAssetsById } from "@happyvertical/smrt-assets";
+//#region src/prompts.ts
+var smrtProfilesGenerateBioPrompt = definePrompt({
+	key: "smrtProfiles.profile.generateBio",
+	template: `Write a short, professional bio for this person.
+
+Profile name: {profileName}
+Profile description: {profileDescription}
+
+Return only the bio text, with no commentary or surrounding quotation marks.`,
+	editable: {
+		template: true,
+		profile: true,
+		model: true,
+		params: true
+	}
+});
+function promptMessageOptions(ai) {
+	return {
+		...ai.params || {},
+		...ai.model ? { model: ai.model } : {},
+		...typeof ai.temperature === "number" ? { temperature: ai.temperature } : {},
+		...typeof ai.maxTokens === "number" ? { maxTokens: ai.maxTokens } : {}
+	};
+}
+//#endregion
+//#region src/auth/normalizeIdentityEmail.ts
+function normalizeIdentityEmail(email) {
+	const normalized = email.trim().toLowerCase();
+	if (!normalized) throw new Error("Identity email normalization requires a non-blank email.");
+	return normalized;
+}
+//#endregion
+//#region src/auth/oidcProvisioningCoordinator.ts
+var provisioningLocks = /* @__PURE__ */ new Map();
+var sqliteRetryLocks = /* @__PURE__ */ new Map();
+var savepointSequence = 0;
+var OIDC_RACE_FIELD_NAMES = /* @__PURE__ */ new Set([
+	"email_key",
+	"emailKey",
+	"identity_key",
+	"identityKey",
+	"profile_id",
+	"profileId"
+]);
+var OIDC_RACE_MESSAGE_PATTERNS = [
+	/oidc_identities[._].*identity_key/iu,
+	/oidc_identities_identity_key/iu,
+	/oidc_profile_email_reservations[._].*(?:email_key|profile_id)/iu,
+	/profile_types_slug_context_meta_type/iu
+];
+var OidcRaceArbiterConflict = class extends Error {
+	constructor(cause) {
+		super("An OIDC provisioning race arbiter reported a unique conflict.", { cause });
+		this.name = "OidcRaceArbiterConflict";
+	}
+};
+var SavepointUnavailableError = class extends Error {
+	constructor(cause) {
+		super("OIDC provisioning could not start a transaction savepoint.", { cause });
+		this.name = "SavepointUnavailableError";
+	}
+};
+async function coordinateOidcProvisioning(options) {
+	const rootBackfillTableReady = typeof options.db.beginTransaction === "function";
+	if (rootBackfillTableReady) await new BackfillTracker({ db: options.db }).initialize();
+	return withProvisioningLocks(options.db, options.lockKeys, async () => {
+		const result = await retryProvisioning(options, () => withProvisioningTransaction(options.db, (tx) => {
+			if (rootBackfillTableReady) BackfillTracker.inheritInitialization(tx, options.db);
+			else BackfillTracker.requireExistingTable(tx);
+			return options.provision(tx);
+		}, options.createTransactionError));
+		return rootBackfillTableReady && options.rebindRootResult ? options.rebindRootResult(result, options.db) : result;
+	});
+}
+async function withProvisioningLocks(db, lockKeys, callback) {
+	const keys = [.../* @__PURE__ */ new Set([...!isPostgresDatabase(db) || typeof db.beginTransaction !== "function" ? ["adapter-transaction"] : [], ...lockKeys])].sort();
+	const acquire = (index) => index >= keys.length ? callback() : withProvisioningLock(db, keys[index], () => acquire(index + 1));
+	return acquire(0);
+}
+function isOidcAbortedTransactionError(error) {
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	while (current instanceof Error && !seen.has(current)) {
+		seen.add(current);
+		if (/current transaction is aborted|transaction.*aborted/iu.test(current.message)) return true;
+		current = current.cause;
+	}
+	return false;
+}
+function testRaceMessagePattern(pattern, message) {
+	pattern.lastIndex = 0;
+	try {
+		return pattern.test(message);
+	} finally {
+		pattern.lastIndex = 0;
+	}
+}
+function isOidcProvisioningRaceConflict(error, options = {}) {
+	if (isOidcAbortedTransactionError(error)) return true;
+	const pending = [error];
+	const seen = /* @__PURE__ */ new Set();
+	const messagePatterns = [...OIDC_RACE_MESSAGE_PATTERNS, ...options.messagePatterns ?? []];
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (!current || typeof current !== "object" || seen.has(current)) continue;
+		seen.add(current);
+		if (current instanceof OidcRaceArbiterConflict) return true;
+		if (current instanceof Error && current.name === "CanonicalPersonProfileError" && current.code === "reservation_conflict") return true;
+		if (current instanceof ValidationError && current.code === "VALIDATION_UNIQUE_CONSTRAINT" && OIDC_RACE_FIELD_NAMES.has(String(current.details?.fieldName ?? ""))) return true;
+		if (current instanceof Error && messagePatterns.some((pattern) => testRaceMessagePattern(pattern, current.message))) return true;
+		const details = current;
+		pending.push(details.cause, details.context, details.details, details.originalError);
+		if (current instanceof AggregateError) pending.push(...current.errors);
+	}
+	return false;
+}
+async function saveOidcRaceArbiter(operation) {
+	try {
+		return await operation();
+	} catch (error) {
+		if (error instanceof ValidationError && error.code === "VALIDATION_UNIQUE_CONSTRAINT" || isOidcAbortedTransactionError(error)) throw new OidcRaceArbiterConflict(error);
+		throw error;
+	}
+}
+async function withProvisioningLock(db, lockKey, callback) {
+	const databaseKey = getDatabaseLockKey(db);
+	const locks = provisioningLocks.get(databaseKey) ?? /* @__PURE__ */ new Map();
+	provisioningLocks.set(databaseKey, locks);
+	const previous = locks.get(lockKey) ?? Promise.resolve();
+	let release;
+	const current = new Promise((resolve) => {
+		release = resolve;
+	});
+	const queued = previous.then(() => current);
+	locks.set(lockKey, queued);
+	await previous;
+	try {
+		return await callback();
+	} finally {
+		release();
+		if (locks.get(lockKey) === queued) locks.delete(lockKey);
+		if (locks.size === 0) provisioningLocks.delete(databaseKey);
+	}
+}
+function getDatabaseLockKey(db) {
+	const url = db.url;
+	if (isPostgresDatabase(db) && typeof db.beginTransaction !== "function" && db.client !== null && (typeof db.client === "object" || typeof db.client === "function")) return db.client;
+	return url && !isPostgresDatabase(db) ? url : db;
+}
+function isPostgresDatabase(db) {
+	return /^postgres(?:ql)?:/iu.test(db.url ?? "");
+}
+async function retryProvisioning(options, callback) {
+	let serializeSqliteRetry = false;
+	for (let attempt = 0; attempt < 8; attempt += 1) try {
+		return await (serializeSqliteRetry ? withSqliteRetryLock(options.db, callback) : callback());
+	} catch (error) {
+		if (error instanceof BackfillTableUnavailableError) {
+			if (typeof options.db.beginTransaction === "function" && attempt < 7) {
+				BackfillTracker.invalidateInitialization(options.db);
+				await new BackfillTracker({ db: options.db }).initialize();
+				continue;
+			}
+			throw options.createTransactionError("Transaction-bound OIDC provisioning requires an existing _smrt_backfills table; pass the root database so SMRT can initialize it safely.", error);
+		}
+		const sqliteBusy = isSqliteBusyError(error);
+		const postgresTransactionRetry = isPostgresTransactionRetryError(error);
+		const raceConflict = options.isRaceConflict(error);
+		if (!sqliteBusy && !postgresTransactionRetry && !raceConflict) throw error;
+		if (sqliteBusy && attempt < 7) {
+			serializeSqliteRetry = true;
+			await waitForRetry(Math.min(100 * 2 ** attempt, 1e3));
+			continue;
+		}
+		if (postgresTransactionRetry && attempt < 7) {
+			await waitForRetry(Math.min(25 * 2 ** attempt, 500));
+			continue;
+		}
+		if (raceConflict && attempt === 0) continue;
+		throw options.createConcurrencyError(error);
+	}
+	throw options.createConcurrencyError();
+}
+function isPostgresTransactionRetryError(error) {
+	const pending = [error];
+	const seen = /* @__PURE__ */ new Set();
+	const messagePattern = /deadlock detected|could not serialize access|serialization failure/iu;
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (!current || typeof current !== "object" || seen.has(current)) continue;
+		seen.add(current);
+		const details = current;
+		if (details.code === "40P01" || details.code === "40001") return true;
+		if (current instanceof Error && messagePattern.test(current.message)) return true;
+		pending.push(details.cause, details.context, details.originalError);
+		if (current instanceof AggregateError) pending.push(...current.errors);
+	}
+	return false;
+}
+async function withSqliteRetryLock(db, callback) {
+	const key = db.url || db;
+	const previous = sqliteRetryLocks.get(key) ?? Promise.resolve();
+	let release;
+	const current = new Promise((resolve) => {
+		release = resolve;
+	});
+	const queued = previous.then(() => current);
+	sqliteRetryLocks.set(key, queued);
+	await previous;
+	try {
+		return await callback();
+	} finally {
+		release();
+		if (sqliteRetryLocks.get(key) === queued) sqliteRetryLocks.delete(key);
+	}
+}
+function isSqliteBusyError(error) {
+	const pending = [error];
+	const seen = /* @__PURE__ */ new Set();
+	const busyPattern = /SQLITE_(?:BUSY|LOCKED)|database(?: table)? is locked|cannot (?:commit transaction|release savepoint) - SQL statements in progress/iu;
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (typeof current === "string") {
+			if (busyPattern.test(current)) return true;
+			continue;
+		}
+		if (!current || typeof current !== "object" || seen.has(current)) continue;
+		seen.add(current);
+		if (current instanceof Error) {
+			if (busyPattern.test(current.message)) return true;
+			pending.push(current.cause);
+			if (current instanceof AggregateError) pending.push(...current.errors);
+		}
+		const details = current;
+		pending.push(details.context, details.details, details.originalError);
+	}
+	return false;
+}
+async function waitForRetry(milliseconds) {
+	await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function withProvisioningTransaction(db, callback, createTransactionError) {
+	if (typeof db.beginTransaction === "function") {
+		if (db.transaction) return db.transaction((tx2) => callback(tx2));
+		const tx = await db.beginTransaction();
+		try {
+			const result = await callback(tx);
+			await tx.commit();
+			return result;
+		} catch (error) {
+			try {
+				if (tx.isActive()) await tx.rollback();
+			} catch (rollbackError) {
+				throw createTransactionError("OIDC provisioning could not roll back its root transaction.", new AggregateError([error, rollbackError]));
+			}
+			throw error;
+		}
+	}
+	try {
+		return await withSavepoint(db, () => callback(db), createTransactionError);
+	} catch (error) {
+		if (!(error instanceof SavepointUnavailableError)) throw error;
+		throw createTransactionError("OIDC provisioning requires a root database or a transaction handle that supports savepoints.", error.cause);
+	}
+}
+async function withSavepoint(db, callback, createTransactionError) {
+	savepointSequence = (savepointSequence + 1) % Number.MAX_SAFE_INTEGER;
+	const savepoint = `smrt_oidc_${savepointSequence.toString(36)}`;
+	try {
+		await db.query(`SAVEPOINT ${savepoint}`);
+	} catch (error) {
+		throw new SavepointUnavailableError(error);
+	}
+	try {
+		const result = await callback();
+		await db.query(`RELEASE SAVEPOINT ${savepoint}`);
+		return result;
+	} catch (error) {
+		try {
+			await db.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+			await db.query(`RELEASE SAVEPOINT ${savepoint}`);
+		} catch (rollbackError) {
+			throw createTransactionError("OIDC provisioning could not roll back its transaction savepoint.", new AggregateError([error, rollbackError]));
+		}
+		throw error;
+	}
+}
+//#endregion
+//#region src/migrations/backfillProfileEmailKeys.ts
+var PROFILE_EMAIL_KEY_BACKFILL_NAME = "@happyvertical/smrt-profiles:profile-email-keys:v1";
+async function backfillProfileEmailKeys(db) {
+	if (!db.transaction) throw new Error("Profile email-key backfill requires a root database with transaction().");
+	await new BackfillTracker({ db }).initialize();
+	return db.transaction(async (tx) => {
+		BackfillTracker.inheritInitialization(tx, db);
+		const result = await tx.query("SELECT id, email, email_key FROM profiles ORDER BY id");
+		const updates = [];
+		for (const row of result.rows) {
+			const id = typeof row.id === "string" ? row.id : "";
+			if (!id) throw new Error("Profile email-key backfill found a row without an id.");
+			const email = typeof row.email === "string" ? row.email : "";
+			const emailKey = email.trim() ? normalizeIdentityEmail(email) : null;
+			if ((typeof row.email_key === "string" ? row.email_key : null) !== emailKey) updates.push({
+				emailKey,
+				id
+			});
+		}
+		for (const update of updates) await tx.query("UPDATE profiles SET email_key = ? WHERE id = ?", update.emailKey, update.id);
+		await new BackfillTracker({ db: tx }).recordApplied(PROFILE_EMAIL_KEY_BACKFILL_NAME, {
+			description: "Canonical Profile identity email keys are current.",
+			packageName: "@happyvertical/smrt-profiles"
+		});
+		return { updated: updates.length };
+	});
+}
+//#endregion
+//#region src/models/OidcProfileEmailReservation.ts
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$2(target, key, result);
+	return result;
+};
+var OidcProfileEmailReservation = class extends SmrtObject {
+	profileId;
+	emailKey = "";
+	constructor(options = {}) {
+		super(options);
+		if (options.profileId !== void 0) this.profileId = options.profileId;
+		if (options.emailKey !== void 0) this.emailKey = options.emailKey;
+	}
+};
+__decorateClass$2([foreignKey("Profile", {
+	required: true,
+	unique: true
+})], OidcProfileEmailReservation.prototype, "profileId", 2);
+__decorateClass$2([field({
+	type: "text",
+	required: true,
+	unique: true,
+	readonly: true
+})], OidcProfileEmailReservation.prototype, "emailKey", 2);
+OidcProfileEmailReservation = __decorateClass$2([smrt({
+	tableName: "oidc_profile_email_reservations",
+	api: false,
+	mcp: false,
+	cli: false
+})], OidcProfileEmailReservation);
+//#endregion
+//#region src/models/ProfileType.ts
+var ProfileType_exports = /* @__PURE__ */ __exportAll({ ProfileType: () => ProfileType });
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$1(target, key, result);
+	return result;
+};
+var ProfileType = class extends SmrtObject {
+	tenantId = null;
+	name = "";
+	description;
+	constructor(options = {}) {
+		super(options);
+		if (options.name) this.name = options.name;
+		if (options.description !== void 0) this.description = options.description;
+	}
+	/**
+	* Convenience method for slug-based lookup
+	*
+	* @param slug - The slug to search for
+	* @returns ProfileType instance or null if not found
+	*/
+	static async getBySlug(_slug) {
+		return null;
+	}
+};
+__decorateClass$1([tenantId({ nullable: true })], ProfileType.prototype, "tenantId", 2);
+__decorateClass$1([field({ required: true })], ProfileType.prototype, "name", 2);
+ProfileType = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt({
+	tableStrategy: "sti",
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: true
+})], ProfileType);
+//#endregion
+//#region src/models/Profile.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+var Profile = class extends SmrtObject {
+	tenantId = null;
+	typeId;
+	email;
+	emailKey = null;
+	name = "";
+	description;
+	metadata = [];
+	relationshipsFrom = [];
+	relationshipsTo = [];
+	constructor(options = {}) {
+		super(options);
+		if (options.typeId !== void 0) this.typeId = options.typeId;
+		if (options.email !== void 0) this.email = options.email;
+		if (options.name) this.name = options.name;
+		if (options.description !== void 0) this.description = options.description;
+	}
+	/** Keep the durable identity key derived from the public email field. */
+	async save() {
+		this.emailKey = this.email?.trim() ? normalizeIdentityEmail(this.email) : null;
+		return super.save();
+	}
+	/**
+	* Get the profile type slug for this profile
+	*
+	* @returns The slug of the profile type
+	*/
+	async getTypeSlug() {
+		return (await this.loadRelated("typeId"))?.slug || "";
+	}
+	/**
+	* Set the profile type by slug
+	*
+	* @param slug - The slug of the profile type
+	* @throws Error if profile type not found
+	*/
+	async setTypeBySlug(slug) {
+		const type = await ProfileType.getBySlug(slug);
+		if (!type) throw new Error(`Profile type '${slug}' not found`);
+		this.typeId = type.id;
+	}
+	/**
+	* Add metadata to this profile
+	*
+	* @param metafieldSlug - The slug of the metafield
+	* @param value - The value to set
+	*/
+	async addMetadata(metafieldSlug, value) {
+		const { ProfileMetafieldCollection } = await import("./ProfileMetafieldCollection-CACMY1hl.js").then((n) => n.n);
+		const { ProfileMetadataCollection } = await import("./ProfileMetadataCollection-loKVv_pj.js").then((n) => n.n);
+		const metafield = await (await ProfileMetafieldCollection.create(this.options)).getBySlug(metafieldSlug);
+		if (!metafield) throw new Error(`Metafield '${metafieldSlug}' not found`);
+		await metafield.validateValue(value);
+		const metadataCollection = await ProfileMetadataCollection.create(this.options);
+		const existing = await metadataCollection.list({
+			where: {
+				profileId: this.id,
+				metafieldId: metafield.id
+			},
+			limit: 1
+		});
+		if (existing.length > 0) {
+			const metadata = existing[0];
+			metadata.value = String(value);
+			await metadata.save();
+		} else {
+			if (!this.id || !metafield.id) throw new Error("Profile.addMetadata requires a persisted profile and metafield (missing id)");
+			await (await metadataCollection.create({
+				profileId: this.id,
+				metafieldId: metafield.id,
+				value: String(value)
+			})).save();
+		}
+	}
+	/**
+	* Get all metadata for this profile as key-value object
+	*
+	* @returns Object with metafield slugs as keys
+	*/
+	async getMetadata() {
+		const { ProfileMetadataCollection } = await import("./ProfileMetadataCollection-loKVv_pj.js").then((n) => n.n);
+		return await (await ProfileMetadataCollection.create(this.options)).getMetadataObject(this.id);
+	}
+	/**
+	* Update multiple metadata values
+	*
+	* @param metadata - Object with metafield slugs as keys and values
+	*/
+	async updateMetadata(metadata) {
+		for (const [metafieldSlug, value] of Object.entries(metadata)) await this.addMetadata(metafieldSlug, value);
+	}
+	/**
+	* Remove metadata by metafield slug
+	*
+	* @param metafieldSlug - The slug of the metafield to remove
+	*/
+	async removeMetadata(metafieldSlug) {
+		const { ProfileMetafieldCollection } = await import("./ProfileMetafieldCollection-CACMY1hl.js").then((n) => n.n);
+		const { ProfileMetadataCollection } = await import("./ProfileMetadataCollection-loKVv_pj.js").then((n) => n.n);
+		const metafield = await (await ProfileMetafieldCollection.create(this.options)).getBySlug(metafieldSlug);
+		if (!metafield) throw new Error(`Metafield '${metafieldSlug}' not found`);
+		const existing = await (await ProfileMetadataCollection.create(this.options)).list({
+			where: {
+				profileId: this.id,
+				metafieldId: metafield.id
+			},
+			limit: 1
+		});
+		if (existing.length > 0) await existing[0].delete();
+	}
+	async getProfileAssetCollection() {
+		const { ProfileAssetCollection } = await import("./ProfileAssetCollection-CtlvXbGy.js").then((n) => n.n);
+		return ProfileAssetCollection.create({ db: this.db });
+	}
+	async getAssets(relationship) {
+		if (!this.id) return [];
+		const linkedAssets = await (await this.getProfileAssetCollection()).byLeft(this.id, relationship ? { relationship } : {});
+		return resolveOwnedAssetsById(this.db, linkedAssets.map((link) => link.assetId), this.tenantId);
+	}
+	async addAsset(asset, relationship = "attachment", sortOrder = 0) {
+		if (!this.id || !asset.id) throw new Error("Cannot associate unsaved profile or asset");
+		assertValidOwnedAssetRelationship(relationship);
+		assertValidOwnedAssetSortOrder(sortOrder);
+		await (await this.getProfileAssetCollection()).attach(this.id, asset.id, {
+			relationship,
+			sortOrder,
+			tenantId: this.tenantId
+		});
+	}
+	async removeAsset(assetId, relationship) {
+		if (!this.id) return;
+		await (await this.getProfileAssetCollection()).detach(this.id, assetId, relationship ? { relationship } : {});
+	}
+	/**
+	* Add a relationship to another profile
+	*
+	* @param toProfile - The target profile
+	* @param relationshipSlug - The type of relationship
+	* @param contextProfile - Optional context profile for tertiary relationships
+	*/
+	async addRelationship(toProfile, relationshipSlug, contextProfile) {
+		const { ProfileRelationshipTypeCollection } = await import("./ProfileRelationshipTypeCollection-Bh4xJ4-I.js").then((n) => n.n);
+		const { ProfileRelationshipCollection } = await import("./ProfileRelationshipCollection-CzQKfvMy.js").then((n) => n.n);
+		const { ProfileRelationshipType } = await import("./ProfileRelationshipType-BjoaCt-u.js").then((n) => n.n);
+		const relationshipType = await (await ProfileRelationshipTypeCollection.create(this.options)).getBySlug(relationshipSlug);
+		if (!relationshipType) throw new Error(`Relationship type '${relationshipSlug}' not found`);
+		const relationshipCollection = await ProfileRelationshipCollection.create(this.options);
+		if (!await relationshipCollection.exists(this.id, toProfile.id, relationshipType.id)) {
+			await (await relationshipCollection.create({
+				fromProfileId: this.id ?? void 0,
+				toProfileId: toProfile.id ?? void 0,
+				typeId: relationshipType.id ?? void 0,
+				contextProfileId: contextProfile?.id ?? void 0
+			})).save();
+			if (relationshipType.reciprocal) {
+				const handler = ProfileRelationshipType.getReciprocalHandler(relationshipSlug);
+				if (handler) await handler(this, toProfile, contextProfile);
+			}
+		}
+	}
+	/**
+	* Get all relationships for this profile
+	*
+	* @param options - Filter options (typeSlug, direction)
+	* @returns Array of ProfileRelationship instances
+	*/
+	async getRelationships(options) {
+		const { ProfileRelationshipCollection } = await import("./ProfileRelationshipCollection-CzQKfvMy.js").then((n) => n.n);
+		const { ProfileRelationshipTypeCollection } = await import("./ProfileRelationshipTypeCollection-Bh4xJ4-I.js").then((n) => n.n);
+		const relationshipCollection = await ProfileRelationshipCollection.create(this.options);
+		const direction = options?.direction || "all";
+		let typeId;
+		if (options?.typeSlug) typeId = (await (await ProfileRelationshipTypeCollection.create(this.options)).getBySlug(options.typeSlug))?.id ?? void 0;
+		if (direction === "from") return await relationshipCollection.getFromProfile(this.id, typeId);
+		else if (direction === "to") return await relationshipCollection.getToProfile(this.id, typeId);
+		else return await relationshipCollection.getForProfile(this.id, typeId);
+	}
+	/**
+	* Get related profiles
+	*
+	* @param relationshipSlug - Optional filter by relationship type slug
+	* @returns Array of related Profile instances
+	*/
+	async getRelatedProfiles(relationshipSlug) {
+		const { ProfileCollection } = await Promise.resolve().then(() => ProfileCollection_exports);
+		const relationships = await this.getRelationships({
+			typeSlug: relationshipSlug,
+			direction: "all"
+		});
+		const profileCollection = await ProfileCollection.create(this.options);
+		const relatedProfiles = [];
+		const seenIds = /* @__PURE__ */ new Set();
+		for (const relationship of relationships) {
+			const fromId = String(relationship.fromProfileId);
+			const toId = String(relationship.toProfileId);
+			const otherId = fromId === String(this.id) ? toId : fromId;
+			if (!seenIds.has(otherId)) {
+				seenIds.add(otherId);
+				const profile = await profileCollection.get({ id: otherId });
+				if (profile) relatedProfiles.push(profile);
+			}
+		}
+		return relatedProfiles;
+	}
+	/**
+	* Remove a relationship to another profile
+	*
+	* @param toProfile - The target profile
+	* @param relationshipSlug - The type of relationship to remove
+	*/
+	async removeRelationship(toProfile, relationshipSlug) {
+		const { ProfileRelationshipTypeCollection } = await import("./ProfileRelationshipTypeCollection-Bh4xJ4-I.js").then((n) => n.n);
+		const { ProfileRelationshipCollection } = await import("./ProfileRelationshipCollection-CzQKfvMy.js").then((n) => n.n);
+		const relationshipType = await (await ProfileRelationshipTypeCollection.create(this.options)).getBySlug(relationshipSlug);
+		if (!relationshipType) throw new Error(`Relationship type '${relationshipSlug}' not found`);
+		const relationshipCollection = await ProfileRelationshipCollection.create(this.options);
+		const relationships = await relationshipCollection.list({ where: {
+			fromProfileId: this.id,
+			toProfileId: toProfile.id,
+			typeId: relationshipType.id
+		} });
+		for (const relationship of relationships) await relationship.delete();
+		if (relationshipType.reciprocal) {
+			const inverseRelationships = await relationshipCollection.list({ where: {
+				fromProfileId: toProfile.id,
+				toProfileId: this.id,
+				typeId: relationshipType.id
+			} });
+			for (const relationship of inverseRelationships) await relationship.delete();
+		}
+	}
+	/**
+	* AI-powered: Generate a professional bio for this profile
+	*
+	* Uses the `smrtProfiles.profile.generateBio` prompt registered via
+	* `@happyvertical/smrt-prompts`, allowing tenant- or instance-level
+	* overrides of the template, model, and parameters at runtime.
+	*
+	* @returns Generated bio text
+	*/
+	async generateBio() {
+		const db = this.options.db ?? this.options.persistence;
+		const resolvedPrompt = await resolvePrompt(smrtProfilesGenerateBioPrompt.key, {
+			db,
+			tenantId: this.tenantId,
+			variables: {
+				profileName: this.name || "",
+				profileDescription: this.description || ""
+			}
+		});
+		return (await (await this.getAiClient()).message(resolvedPrompt.text, promptMessageOptions(resolvedPrompt.ai))).trim();
+	}
+	/**
+	* AI-powered: Check if profile matches criteria
+	*
+	* @param criteria - Criteria to match against
+	* @returns True if matches criteria
+	*/
+	async matches(criteria) {
+		return await this.is(criteria);
+	}
+	/**
+	* Find profiles by metadata key-value pair
+	*
+	* @param metafieldSlug - The metafield slug to search
+	* @param value - The value to match
+	* @returns Array of matching profiles
+	*/
+	static async findByMetadata(_metafieldSlug, _value) {
+		return [];
+	}
+	/**
+	* Find profiles by type slug
+	*
+	* @param typeSlug - The profile type slug
+	* @returns Array of matching profiles
+	*/
+	static async findByType(_typeSlug) {
+		return [];
+	}
+	/**
+	* Find related profiles for a given profile
+	*
+	* @param profileId - The profile UUID
+	* @param relationshipSlug - Optional filter by relationship type
+	* @returns Array of related profiles
+	*/
+	static async findRelated(_profileId, _relationshipSlug) {
+		return [];
+	}
+	/**
+	* Search profiles by email
+	*
+	* @param email - The email to search for
+	* @returns Profile or null if not found
+	*/
+	static async searchByEmail(_email) {
+		return null;
+	}
+	/**
+	* Get all API keys for this profile
+	*
+	* @returns Array of API keys
+	*/
+	async getApiKeys() {
+		const { ApiKeyCollection } = await import("./ApiKeyCollection-CrTjdMz8.js").then((n) => n.n);
+		return await (await ApiKeyCollection.create(this.options)).findByProfile(this.id);
+	}
+	/**
+	* Get active (non-revoked, non-expired) API keys for this profile
+	*
+	* @returns Array of active API keys
+	*/
+	async getActiveApiKeys() {
+		const { ApiKeyCollection } = await import("./ApiKeyCollection-CrTjdMz8.js").then((n) => n.n);
+		return await (await ApiKeyCollection.create(this.options)).findActiveByProfile(this.id);
+	}
+	/**
+	* Generate a new API key for this profile
+	*
+	* @param options - Key options (name, scopes, expiration)
+	* @returns The generated key (plaintext) and ApiKey record
+	*/
+	async generateApiKey(options) {
+		const { ApiKey } = await import("./ApiKey-Br9NGBnr.js").then((n) => n.n);
+		return await ApiKey.generate(this, {
+			...options,
+			db: this.options?.db
+		});
+	}
+	/**
+	* Get all OIDC identities linked to this profile
+	*
+	* @returns Array of OIDC identity records
+	*/
+	async getOidcIdentities() {
+		const { OidcIdentityCollection } = await import("./OidcIdentityCollection-Ce4yv8p0.js").then((n) => n.r);
+		return await (await OidcIdentityCollection.create(this.options)).findByProfile(this.id);
+	}
+	/**
+	* Reuse an existing exact OIDC identity for this unchanged Profile.
+	*
+	* @param oidcData - OIDC provider data
+	* @returns The linked OIDC identity record
+	* @deprecated New authentication links require owner-aware transactional
+	* provisioning. This compatibility helper may refresh a legacy Profile
+	* type, but refuses to create or rebind authority.
+	*/
+	async linkOidcIdentity(oidcData) {
+		const { OidcIdentityCollection } = await import("./OidcIdentityCollection-Ce4yv8p0.js").then((n) => n.r);
+		return await (await OidcIdentityCollection.create(this.options)).linkToProfile(this, oidcData);
+	}
+	/**
+	* Get all Nostr identities linked to this profile
+	*
+	* @returns Array of Nostr identity records
+	*/
+	async getNostrIdentities() {
+		const { NostrIdentityCollection } = await import("./NostrIdentityCollection-BRYUgt47.js").then((n) => n.n);
+		return await (await NostrIdentityCollection.create(this.options)).findByProfile(this.id);
+	}
+	/**
+	* Link a new Nostr identity to this profile
+	*
+	* @param nostrData - Nostr identity data (encrypted keypair)
+	* @returns The linked Nostr identity record
+	*/
+	async linkNostrIdentity(nostrData) {
+		const { NostrIdentityCollection } = await import("./NostrIdentityCollection-BRYUgt47.js").then((n) => n.n);
+		return await (await NostrIdentityCollection.create(this.options)).linkToProfile(this, nostrData);
+	}
+	/**
+	* Get audit logs for actions performed by this profile
+	*
+	* @param limit - Maximum number of logs to return
+	* @returns Array of audit log entries
+	*/
+	async getAuditLogs(limit = 50) {
+		const { AuditLogCollection } = await import("./AuditLogCollection-BBIEI6BD.js").then((n) => n.n);
+		return await (await AuditLogCollection.create(this.options)).getRecentActivity(this.id, limit);
+	}
+	/**
+	* Record an audit log entry for an action by this profile
+	*
+	* @param options - Audit log options
+	* @returns The created audit log entry
+	*/
+	async recordAction(options) {
+		const { AuditLogCollection } = await import("./AuditLogCollection-BBIEI6BD.js").then((n) => n.n);
+		return await (await AuditLogCollection.create(this.options)).record({
+			profile: this,
+			...options
+		});
+	}
+};
+__decorateClass([tenantId({ nullable: true })], Profile.prototype, "tenantId", 2);
+__decorateClass([foreignKey("ProfileType", { required: true })], Profile.prototype, "typeId", 2);
+__decorateClass([field({ unique: true })], Profile.prototype, "email", 2);
+__decorateClass([field({
+	type: "text",
+	nullable: true,
+	indexed: true,
+	readonly: true
+})], Profile.prototype, "emailKey", 2);
+__decorateClass([field({ required: true })], Profile.prototype, "name", 2);
+__decorateClass([oneToMany("ProfileMetadata")], Profile.prototype, "metadata", 2);
+__decorateClass([oneToMany("ProfileRelationship", { foreignKey: "fromProfileId" })], Profile.prototype, "relationshipsFrom", 2);
+__decorateClass([oneToMany("ProfileRelationship", { foreignKey: "toProfileId" })], Profile.prototype, "relationshipsTo", 2);
+Profile = __decorateClass([TenantScoped({ mode: "optional" }), smrt({
+	tableStrategy: "sti",
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update",
+		"delete"
+	] },
+	mcp: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	cli: true
+})], Profile);
+//#endregion
+//#region src/collections/OidcProfileEmailReservationCollection.ts
+var OidcProfileEmailReservationCollection = class extends SmrtCollection {
+	static _itemClass = OidcProfileEmailReservation;
+};
+//#endregion
+//#region src/collections/ProfileCollection.ts
+var ProfileCollection_exports = /* @__PURE__ */ __exportAll({
+	CanonicalPersonProfileError: () => CanonicalPersonProfileError,
+	ProfileCollection: () => ProfileCollection
+});
+var PERSON_META_TYPES = /* @__PURE__ */ new Set(["@happyvertical/smrt-profiles:Person", "Person"]);
+var CanonicalPersonProfileError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "CanonicalPersonProfileError";
+	}
+	code;
+};
+var ProfileCollection = class extends SmrtCollection {
+	static _itemClass = Profile;
+	emailKeysReadyPromise = null;
+	/**
+	* Find a profile by email address
+	*
+	* @param email - The email address to search for
+	* @returns The matching profile or null
+	*/
+	async findByEmail(email) {
+		const normalizedEmail = normalizeIdentityEmail(email);
+		return (await this.list({
+			where: { email: normalizedEmail },
+			limit: 1
+		}))[0] ?? null;
+	}
+	/**
+	* Resolve one unambiguous global Person by normalized email.
+	*
+	* Unlike `findByEmail()`, this identity-boundary helper deliberately reads
+	* across tenant scopes and fails closed when any matching row is
+	* tenant-scoped, is not a Person STI row, or when more than one row matches
+	* case-insensitively. It is intended for verified external identities.
+	*/
+	async findUniqueGlobalPersonByEmail(email) {
+		const normalizedEmail = normalizeIdentityEmail(email);
+		const rows = await this.loadCanonicalEmailRows(normalizedEmail);
+		if (rows.length === 0) return null;
+		this.assertCanonicalRows(rows, normalizedEmail);
+		return this.requireHydratedProfile(readRequiredString(rows[0], "id"));
+	}
+	/**
+	* Validate and hydrate a supplied canonical Profile.
+	*
+	* The Profile must be the sole case-insensitive match for its stored email.
+	* When `email` is provided, that address must also match the stored email.
+	*/
+	async requireCanonicalGlobalPerson(profileId, email) {
+		const db = this.requireDatabase();
+		await this.ensureEmailKeysReady();
+		const row = (await withSystemContext(() => db.query(`SELECT id, tenant_id, _meta_type, email, email_key
+         FROM profiles
+         WHERE id = ?
+         LIMIT 1`, profileId))).rows[0];
+		if (!row) throw new CanonicalPersonProfileError("missing_profile", `Profile ${profileId} does not exist.`);
+		this.assertRowEmailKeyCurrent(row);
+		this.assertCanonicalRows([row]);
+		const storedEmail = readString(row, "email");
+		const normalizedEmail = email !== void 0 ? normalizeIdentityEmail(email) : storedEmail ? normalizeIdentityEmail(storedEmail) : void 0;
+		if (normalizedEmail !== void 0) {
+			const matches = await this.loadCanonicalEmailRows(normalizedEmail);
+			this.assertCanonicalRows(matches, normalizedEmail);
+			if (matches.length !== 1 || readRequiredString(matches[0], "id") !== profileId) throw new CanonicalPersonProfileError("email_mismatch", `Profile ${profileId} is not the unique global Person for ${normalizedEmail}.`);
+		}
+		return this.requireHydratedProfile(profileId);
+	}
+	/**
+	* Reserve the normalized email for a previously validated canonical Person.
+	*
+	* The unique stored key turns a concurrent OIDC first-login race into a
+	* retryable database conflict. Legacy Profiles remain unaffected until an
+	* identity boundary safely claims them.
+	*/
+	async reserveCanonicalIdentityEmail(profileId, email) {
+		const profile = await this.requireCanonicalGlobalPerson(profileId, email);
+		const normalizedEmail = email !== void 0 ? normalizeIdentityEmail(email) : profile.email?.trim() ? normalizeIdentityEmail(profile.email) : null;
+		const db = this.requireDatabase();
+		const reservations = await OidcProfileEmailReservationCollection.create({ db });
+		const byProfile = await reservations.list({
+			where: { profileId },
+			limit: 2
+		});
+		if (byProfile.length > 1) throw new CanonicalPersonProfileError("ambiguous_email", `Multiple canonical identity reservations exist for Profile ${profileId}.`);
+		if (normalizedEmail === null) {
+			await byProfile[0]?.delete();
+			return profile;
+		}
+		const byEmail = await reservations.list({
+			where: { emailKey: normalizedEmail },
+			limit: 2
+		});
+		const activeEmailReservations = [];
+		for (const reservation of byEmail) if (reservation.profileId !== profileId && await this.isStaleEmailReservation(reservation, normalizedEmail)) await reservation.delete();
+		else activeEmailReservations.push(reservation);
+		if (activeEmailReservations.find((reservation) => reservation.profileId !== profileId)) throw new CanonicalPersonProfileError("reservation_conflict", `${normalizedEmail} is already reserved for a different canonical Person.`);
+		if (activeEmailReservations.length > 1) throw new CanonicalPersonProfileError("ambiguous_email", `Multiple canonical identity reservations exist for ${normalizedEmail}.`);
+		const existing = byProfile[0];
+		if (existing) {
+			if (existing.emailKey !== normalizedEmail) {
+				existing.emailKey = normalizedEmail;
+				await saveIdentityEmailReservation(existing, normalizedEmail);
+			}
+			return profile;
+		}
+		if (!activeEmailReservations[0]) {
+			const reservation = new OidcProfileEmailReservation({
+				db,
+				emailKey: normalizedEmail,
+				profileId
+			});
+			await reservation.initialize();
+			await saveIdentityEmailReservation(reservation, normalizedEmail);
+		}
+		return profile;
+	}
+	/**
+	* Find profiles by type slug
+	*
+	* @param typeSlug - The profile type slug to filter by
+	* @returns Array of matching profiles
+	*/
+	async findByType(typeSlug) {
+		const allProfiles = await this.list({});
+		const filtered = [];
+		for (const profile of allProfiles) if (await profile.getTypeSlug() === typeSlug) filtered.push(profile);
+		return filtered;
+	}
+	requireDatabase() {
+		const db = this.options.db;
+		if (!db || typeof db !== "object" || !("query" in db)) throw new Error("Canonical Profile identity resolution requires an initialized database.");
+		return db;
+	}
+	async loadCanonicalEmailRows(normalizedEmail) {
+		const db = this.requireDatabase();
+		await this.ensureEmailKeysReady();
+		const rows = (await withSystemContext(async () => {
+			return db.query(`SELECT id, tenant_id, _meta_type, email, email_key
+         FROM profiles
+         WHERE email_key = ?
+         ORDER BY created_at ASC, id ASC
+         LIMIT 2`, normalizedEmail);
+		})).rows;
+		for (const row of rows) this.assertRowEmailKeyCurrent(row, normalizedEmail);
+		return rows;
+	}
+	/** Require the deploy-time backfill marker before indexed identity reads. */
+	async ensureEmailKeysReady() {
+		if (!this.emailKeysReadyPromise) this.emailKeysReadyPromise = this.checkEmailKeysReady().catch((error) => {
+			this.emailKeysReadyPromise = null;
+			throw error;
+		});
+		return this.emailKeysReadyPromise;
+	}
+	async checkEmailKeysReady() {
+		if (await new BackfillTracker({ db: this.requireDatabase() }).isApplied("@happyvertical/smrt-profiles:profile-email-keys:v1")) return;
+		throw new CanonicalPersonProfileError("email_key_backfill_required", "Profile identity email keys are not marked ready; run backfillProfileEmailKeys() before identity lookup.");
+	}
+	async isStaleEmailReservation(reservation, reservedEmail) {
+		const profileId = reservation.profileId;
+		if (!profileId) return true;
+		const row = (await this.requireDatabase().query("SELECT email FROM profiles WHERE id = ? LIMIT 1", profileId)).rows[0];
+		if (!row) return true;
+		const email = readString(row, "email");
+		return !email?.trim() || normalizeIdentityEmail(email) !== reservedEmail;
+	}
+	assertRowEmailKeyCurrent(row, normalizedEmail) {
+		const email = readString(row, "email") ?? "";
+		const expectedKey = email.trim() ? normalizeIdentityEmail(email) : null;
+		if ((readString(row, "email_key") ?? null) !== expectedKey || normalizedEmail !== void 0 && expectedKey !== normalizedEmail) throw new CanonicalPersonProfileError("email_key_backfill_required", `Profile ${String(row.id ?? "<unknown>")} has a missing or stale identity email key; run backfillProfileEmailKeys() before identity lookup.`);
+	}
+	assertCanonicalRows(rows, normalizedEmail) {
+		const tenantScoped = rows.find((row) => readString(row, "tenant_id"));
+		if (tenantScoped) throw new CanonicalPersonProfileError("tenant_scoped", `Profile ${readRequiredString(tenantScoped, "id")} for ${normalizedEmail ?? "the supplied identity"} is tenant-scoped.`);
+		const nonPerson = rows.find((row) => !PERSON_META_TYPES.has(readString(row, "_meta_type") ?? ""));
+		if (nonPerson) throw new CanonicalPersonProfileError("non_person", `Profile ${readRequiredString(nonPerson, "id")} for ${normalizedEmail ?? "the supplied identity"} is not a Person.`);
+		if (rows.length > 1) throw new CanonicalPersonProfileError("ambiguous_email", `Multiple Profiles use ${normalizedEmail ?? "the supplied identity email"}.`);
+	}
+	async requireHydratedProfile(profileId) {
+		const profile = await withSystemContext(() => this.get({ id: profileId }));
+		if (!profile) throw new CanonicalPersonProfileError("missing_profile", `Profile ${profileId} could not be hydrated.`);
+		return profile;
+	}
+	/**
+	* Batch get metadata for multiple profiles
+	*
+	* @param profileIds - Array of profile UUIDs
+	* @returns Map of profile ID to metadata object
+	*/
+	async batchGetMetadata(profileIds) {
+		const result = /* @__PURE__ */ new Map();
+		for (const profileId of profileIds) {
+			const profile = await this.get({ id: profileId });
+			if (profile) {
+				const metadata = await profile.getMetadata();
+				result.set(profileId, metadata);
+			}
+		}
+		return result;
+	}
+	/**
+	* Batch update metadata for multiple profiles
+	*
+	* @param updates - Array of { profileId, data } objects
+	*/
+	async batchUpdateMetadata(updates) {
+		for (const update of updates) {
+			const profile = await this.get({ id: update.profileId });
+			if (profile) await profile.updateMetadata(update.data);
+		}
+	}
+	/**
+	* Find related profiles for a given profile
+	*
+	* @param profileId - The profile UUID
+	* @param relationshipSlug - Optional filter by relationship type
+	* @returns Array of related profiles
+	*/
+	async findRelated(profileId, relationshipSlug) {
+		const profile = await this.get({ id: profileId });
+		if (!profile) return [];
+		return await profile.getRelatedProfiles(relationshipSlug);
+	}
+	async getAssets(profileId, relationship) {
+		return getOwnedAssetsFromCollection(this, profileId, relationship);
+	}
+	async addAsset(profileId, asset, relationship = "attachment", sortOrder = 0) {
+		await addOwnedAssetFromCollection(this, "Profile", profileId, asset, relationship, sortOrder);
+	}
+	async removeAsset(profileId, assetId, relationship) {
+		await removeOwnedAssetFromCollection(this, "Profile", profileId, assetId, relationship);
+	}
+	/**
+	* Get the relationship network for a profile up to a maximum depth
+	*
+	* @param profileId - The starting profile UUID
+	* @param options - Configuration options
+	* @returns Map of profile ID to depth level
+	*/
+	async getRelationshipNetwork(profileId, options = {}) {
+		const maxDepth = options.maxDepth || 2;
+		const network = /* @__PURE__ */ new Map();
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [{
+			id: profileId,
+			depth: 0
+		}];
+		while (queue.length > 0) {
+			const current = queue.shift();
+			if (!current) break;
+			if (visited.has(current.id) || current.depth > maxDepth) continue;
+			visited.add(current.id);
+			network.set(current.id, current.depth);
+			if (current.depth < maxDepth) {
+				const related = await this.findRelated(current.id);
+				for (const profile of related) if (profile.id && !visited.has(profile.id)) queue.push({
+					id: profile.id,
+					depth: current.depth + 1
+				});
+			}
+		}
+		return network;
+	}
+	/**
+	* Find all profiles belonging to a specific tenant
+	*
+	* @param tenantId - The tenant UUID to filter by
+	* @returns Array of profiles for this tenant
+	*/
+	async findByTenant(tenantId) {
+		return this.list({ where: { tenantId } });
+	}
+	/**
+	* Find all global profiles (no tenant association).
+	*
+	* Routes through the shared tenant-global helper so it does not throw under
+	* an active tenant context (an explicit `tenant_id IS NULL` filter would be
+	* flagged as an isolation violation). (#1600)
+	*
+	* @returns Array of profiles with null tenantId
+	*/
+	async findGlobal() {
+		return queryGlobal(this);
+	}
+	/**
+	* Find profiles belonging to a tenant plus all global profiles.
+	*
+	* Fails closed if an active tenant context requests a different tenant's
+	* rows; the admin/system path keeps the cross-tenant capability. (#1600)
+	*
+	* @param tenantId - The tenant UUID to include
+	* @returns Array of tenant-specific and global profiles
+	*/
+	async findWithGlobals(tenantId) {
+		return queryWithGlobals(this, tenantId, "Profile.findWithGlobals");
+	}
+};
+async function saveIdentityEmailReservation(reservation, normalizedEmail) {
+	try {
+		await reservation.save();
+	} catch (error) {
+		if (error instanceof ValidationError && error.code === "VALIDATION_UNIQUE_CONSTRAINT" || isOidcAbortedTransactionError(error)) throw new CanonicalPersonProfileError("reservation_conflict", `${normalizedEmail} was concurrently reserved for another canonical Person.`);
+		throw error;
+	}
+}
+function readString(row, key) {
+	const value = row[key];
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readRequiredString(row, key) {
+	const value = readString(row, key);
+	if (!value) throw new Error(`Canonical Profile identity row is missing ${key}.`);
+	return value;
+}
+//#endregion
+export { ProfileType as a, backfillProfileEmailKeys as c, isOidcProvisioningRaceConflict as d, saveOidcRaceArbiter as f, smrtProfilesGenerateBioPrompt as h, Profile as i, coordinateOidcProvisioning as l, promptMessageOptions as m, ProfileCollection as n, ProfileType_exports as o, normalizeIdentityEmail as p, ProfileCollection_exports as r, PROFILE_EMAIL_KEY_BACKFILL_NAME as s, CanonicalPersonProfileError as t, isOidcAbortedTransactionError as u };
+
+//# sourceMappingURL=ProfileCollection-Bix9yAiy.js.map