@happyvertical/smrt-cli 0.51.15 → 0.51.16

package/dist/ProfileCollection-BvhD2cfL-CT6ctQ3l.js

@@ -0,0 +1,1753 @@
+import { t as __exportAll$1 } from "./rolldown-runtime-8H4AJuhK.js";
+import { n as __exportAll$2 } from "./NostrIdentity-n70E0vck-CZwoR7Rs.js";
+import { a as getTenantId, i as queryWithGlobals, n as tenantId, r as queryGlobal, s as withSystemContext, t as TenantScoped } from "./dist-9EA_5mOX.js";
+import { a as removeOwnedAssetFromCollection, i as getOwnedAssetsFromCollection, n as assertValidOwnedAssetRelationship, o as resolveOwnedAssetsById, r as assertValidOwnedAssetSortOrder, t as addOwnedAssetFromCollection } from "./dist-mLcl4Ttr.js";
+import { ObjectRegistry, SmrtCollection, SmrtObject, ValidationError, field, foreignKey, isAbortedTransactionError, oneToMany, smrt } from "@happyvertical/smrt-core";
+import { getPackageConfig } from "@happyvertical/smrt-config";
+import { BackfillTableUnavailableError, BackfillTracker } from "@happyvertical/smrt-core/migrations";
+//#region ../prompts/dist/index.js
+var __defProp$1$1 = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp$1$1(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp$1$1(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+ObjectRegistry.registerPackageManifest(JSON.parse("{\"version\":\"1.0.0\",\"timestamp\":0,\"packageName\":\"@happyvertical/smrt-prompts\",\"packageVersion\":\"0.51.16\",\"objects\":{\"@happyvertical/smrt-prompts:PromptOverrideCollection\":{\"name\":\"promptoverridecollection\",\"className\":\"PromptOverrideCollection\",\"qualifiedName\":\"@happyvertical/smrt-prompts:PromptOverrideCollection\",\"collection\":\"promptoverrides\",\"filePath\":\"/home/runner/work/smrt/smrt/packages/prompts/src/collections/PromptOverrideCollection.ts\",\"packageName\":\"@happyvertical/smrt-prompts\",\"fields\":{},\"methods\":{\"getAppOverride\":{\"name\":\"getAppOverride\",\"async\":true,\"parameters\":[{\"name\":\"key\",\"type\":\"string\",\"optional\":false},{\"name\":\"options\",\"type\":\"object\",\"optional\":true,\"memberTypes\":[\"string\"]}],\"returnType\":\"Promise<PromptOverride | null>\",\"isStatic\":false,\"isPublic\":true},\"getTenantOverride\":{\"name\":\"getTenantOverride\",\"async\":true,\"parameters\":[{\"name\":\"key\",\"type\":\"string\",\"optional\":false},{\"name\":\"tenantId\",\"type\":\"string\",\"optional\":false},{\"name\":\"options\",\"type\":\"object\",\"optional\":true,\"memberTypes\":[\"string\"]}],\"returnType\":\"Promise<PromptOverride | null>\",\"isStatic\":false,\"isPublic\":true},\"getResolutionLayers\":{\"name\":\"getResolutionLayers\",\"async\":true,\"parameters\":[{\"name\":\"key\",\"type\":\"string\",\"optional\":false},{\"name\":\"tenantId\",\"type\":\"string | null\",\"optional\":true,\"unionBranches\":[{\"type\":\"string\"},{\"type\":\"null\"}]},{\"name\":\"options\",\"type\":\"object\",\"optional\":true,\"memberTypes\":[\"string\"]}],\"returnType\":\"Promise<object>\",\"isStatic\":false,\"isPublic\":true}},\"decoratorConfig\":{\"tableName\":\"_smrt_prompt_overrides\"},\"extends\":\"SmrtCollection\",\"extendsTypeArg\":\"PromptOverride\",\"exportName\":\"PromptOverrideCollection\",\"collectionExportName\":\"PromptOverrideCollectionCollection\",\"schema\":{\"tableName\":\"_smrt_prompt_overrides\",\"ddl\":\"CREATE TABLE IF NOT EXISTS \\\"_smrt_prompt_overrides\\\" (\\n  \\\"id\\\" UUID PRIMARY KEY NOT NULL,\\n  \\\"slug\\\" TEXT NOT NULL,\\n  \\\"context\\\" TEXT NOT NULL DEFAULT '',\\n  \\\"created_at\\\" TIMESTAMP NOT NULL DEFAULT current_timestamp,\\n  \\\"updated_at\\\" TIMESTAMP NOT NULL DEFAULT current_timestamp,\\n  \\\"key\\\" TEXT NOT NULL DEFAULT '',\\n  \\\"tenant_id\\\" TEXT,\\n  \\\"template\\\" TEXT,\\n  \\\"profile\\\" TEXT,\\n  \\\"model\\\" TEXT,\\n  \\\"params\\\" TEXT\\n);\",\"columns\":{\"id\":{\"type\":\"UUID\",\"primaryKey\":true,\"referenceKind\":\"id\",\"notNull\":true},\"slug\":{\"type\":\"TEXT\",\"notNull\":true},\"context\":{\"type\":\"TEXT\",\"notNull\":true,\"default\":\"\"},\"created_at\":{\"type\":\"TIMESTAMP\",\"notNull\":true,\"default\":\"current_timestamp\"},\"updated_at\":{\"type\":\"TIMESTAMP\",\"notNull\":true,\"default\":\"current_timestamp\"},\"key\":{\"type\":\"TEXT\",\"notNull\":true,\"unique\":false,\"default\":\"\"},\"tenant_id\":{\"type\":\"TEXT\",\"notNull\":false,\"unique\":false},\"template\":{\"type\":\"TEXT\",\"notNull\":false,\"unique\":false},\"profile\":{\"type\":\"TEXT\",\"notNull\":false,\"unique\":false},\"model\":{\"type\":\"TEXT\",\"notNull\":false,\"unique\":false},\"params\":{\"type\":\"TEXT\",\"notNull\":false,\"unique\":false}},\"indexes\":[{\"name\":\"_smrt_prompt_overrides_key_context_idx\",\"columns\":[\"key\",\"context\"],\"unique\":true},{\"name\":\"_smrt_prompt_overrides_slug_context_idx\",\"columns\":[\"slug\",\"context\"]},{\"name\":\"_smrt_prompt_overrides_created_at_idx\",\"columns\":[\"created_at\"]}],\"version\":\"6f475427\"},\"importPath\":\"@happyvertical/smrt-prompts\"},\"@happyvertical/smrt-prompts:PromptOverride\":{\"name\":\"promptoverride\",\"className\":\"PromptOverride\",\"qualifiedName\":\"@happyvertical/smrt-prompts:PromptOverride\",\"collection\":\"promptoverrides\",\"filePath\":\"/home/runner/work/smrt/smrt/packages/prompts/src/models/PromptOverride.ts\",\"packageName\":\"@happyvertical/smrt-prompts\",\"fields\":{\"key\":{\"type\":\"text\",\"required\":true,\"default\":\"\",\"_meta\":{\"required\":true}},\"tenantId\":{\"type\":\"text\",\"required\":false,\"_meta\":{\"nullable\":true}},\"template\":{\"type\":\"text\",\"required\":false,\"_meta\":{\"nullable\":true}},\"profile\":{\"type\":\"text\",\"required\":false,\"_meta\":{\"nullable\":true}},\"model\":{\"type\":\"text\",\"required\":false,\"_meta\":{\"nullable\":true}},\"params\":{\"type\":\"text\",\"required\":false,\"_meta\":{\"nullable\":true}}},\"methods\":{\"getParams\":{\"name\":\"getParams\",\"async\":false,\"parameters\":[],\"returnType\":\"PromptParams\",\"isStatic\":false,\"isPublic\":true},\"setParams\":{\"name\":\"setParams\",\"async\":false,\"parameters\":[{\"name\":\"params\",\"type\":\"PromptParams | null\",\"optional\":false,\"unionBranches\":[{\"type\":\"PromptParams\"},{\"type\":\"null\"}]}],\"returnType\":\"void\",\"isStatic\":false,\"isPublic\":true},\"toPromptLayer\":{\"name\":\"toPromptLayer\",\"async\":false,\"parameters\":[],\"returnType\":\"PromptLayer\",\"isStatic\":false,\"isPublic\":true},\"save\":{\"name\":\"save\",\"async\":true,\"parameters\":[],\"returnType\":\"Promise<this>\",\"isStatic\":false,\"isPublic\":true},\"delete\":{\"name\":\"delete\",\"async\":true,\"parameters\":[],\"returnType\":\"Promise<void>\",\"isStatic\":false,\"isPublic\":true}},\"decoratorConfig\":{\"tableName\":\"_smrt_prompt_overrides\",\"conflictColumns\":[\"key\",\"context\"],\"api\":{\"include\":[\"list\",\"get\",\"create\",\"update\",\"delete\"]},\"cli\":{\"include\":[\"list\",\"get\",\"create\",\"update\",\"delete\"],\"exclude\":[\"getParams\",\"setParams\",\"toPromptLayer\"]},\"mcp\":{\"include\":[]}},\"extends\":\"SmrtObject\",\"exportName\":\"PromptOverride\",\"collectionExportName\":\"PromptOverrideCollection\",\"validationRules\":[{\"field\":\"key\",\"rule\":\"required\",\"fieldType\":\"text\"}],\"schema\":{\"tableName\":\"_smrt_prompt_overrides\",\"ddl\":\"CREATE TABLE IF NOT EXISTS \\\"_smrt_prompt_overrides\\\" (\\n  \\\"id\\\" UUID PRIMARY KEY NOT NULL,\\n  \\\"slug\\\" TEXT NOT NULL,\\n  \\\"context\\\" TEXT NOT NULL DEFAULT '',\\n  \\\"created_at\\\" TIMESTAMP NOT NULL DEFAULT current_timestamp,\\n  \\\"updated_at\\\" TIMESTAMP NOT NULL DEFAULT current_timestamp,\\n  \\\"key\\\" TEXT NOT NULL DEFAULT '',\\n  \\\"tenant_id\\\" TEXT,\\n  \\\"template\\\" TEXT,\\n  \\\"profile\\\" TEXT,\\n  \\\"model\\\" TEXT,\\n  \\\"params\\\" TEXT\\n);\",\"columns\":{\"id\":{\"type\":\"UUID\",\"primaryKey\":true,\"referenceKind\":\"id\",\"notNull\":true},\"slug\":{\"type\":\"TEXT\",\"notNull\":true},\"context\":{\"type\":\"TEXT\",\"notNull\":true,\"default\":\"\"},\"created_at\":{\"type\":\"TIMESTAMP\",\"notNull\":true,\"default\":\"current_timestamp\"},\"updated_at\":{\"type\":\"TIMESTAMP\",\"notNull\":true,\"default\":\"current_timestamp\"},\"key\":{\"type\":\"TEXT\",\"notNull\":true,\"unique\":false,\"default\":\"\"},\"tenant_id\":{\"type\":\"TEXT\",\"notNull\":false,\"unique\":false},\"template\":{\"type\":\"TEXT\",\"notNull\":false,\"unique\":false},\"profile\":{\"type\":\"TEXT\",\"notNull\":false,\"unique\":false},\"model\":{\"type\":\"TEXT\",\"notNull\":false,\"unique\":false},\"params\":{\"type\":\"TEXT\",\"notNull\":false,\"unique\":false}},\"indexes\":[{\"name\":\"_smrt_prompt_overrides_key_context_idx\",\"columns\":[\"key\",\"context\"],\"unique\":true},{\"name\":\"_smrt_prompt_overrides_slug_context_idx\",\"columns\":[\"slug\",\"context\"]},{\"name\":\"_smrt_prompt_overrides_created_at_idx\",\"columns\":[\"created_at\"]}],\"version\":\"6f475427\"},\"importPath\":\"@happyvertical/smrt-prompts\"}},\"moduleType\":\"smrt\",\"smrtDependencies\":[\"@happyvertical/smrt-core\",\"@happyvertical/smrt-tenancy\"]}"));
+var PROMPT_CACHE_TTL_MS = 3e4;
+var promptCache = /* @__PURE__ */ new Map();
+var cacheGenerations = /* @__PURE__ */ new Map();
+var nextGeneration = 1;
+var clearedThrough = 0;
+var dbInstanceIds = /* @__PURE__ */ new WeakMap();
+var nextDbId = 1;
+function getDbNamespace(db) {
+	if (!db) return "no-db";
+	if (typeof db === "string") return `db:${db}`;
+	if (typeof db === "object") {
+		const dbObject = db;
+		if (typeof dbObject.query === "function") {
+			if (!dbInstanceIds.has(dbObject)) dbInstanceIds.set(dbObject, `db-instance:${nextDbId++}`);
+			const namespace = dbInstanceIds.get(dbObject);
+			if (namespace) return namespace;
+			return "db-instance:unknown";
+		}
+		try {
+			return `db-config:${JSON.stringify(dbObject)}`;
+		} catch {
+			return "db-config:opaque";
+		}
+	}
+	return "db:unknown";
+}
+function buildCacheKey(key, tenantId, db) {
+	return `${getDbNamespace(db)}::${key}::${tenantId ?? "app"}`;
+}
+function buildGenerationKey(key, db) {
+	return `${getDbNamespace(db)}::${key}`;
+}
+function bumpGeneration(key, db) {
+	cacheGenerations.set(buildGenerationKey(key, db), nextGeneration++);
+}
+function getCachedPromptBase(key, tenantId, db) {
+	const cacheKey = buildCacheKey(key, tenantId, db);
+	const cached = promptCache.get(cacheKey);
+	if (!cached) return null;
+	if (cached.expiresAt <= Date.now()) {
+		promptCache.delete(cacheKey);
+		return null;
+	}
+	return cached.value;
+}
+function getPromptCacheGeneration(key, db) {
+	const generation = cacheGenerations.get(buildGenerationKey(key, db)) ?? 0;
+	return generation > clearedThrough ? generation : clearedThrough;
+}
+function setCachedPromptBase(key, tenantId, db, value, loadedAtGeneration) {
+	if (getPromptCacheGeneration(key, db) !== loadedAtGeneration) return;
+	promptCache.set(buildCacheKey(key, tenantId, db), {
+		expiresAt: Date.now() + PROMPT_CACHE_TTL_MS,
+		value
+	});
+}
+function invalidatePromptCache(key, tenantId, db) {
+	const dbNamespace = getDbNamespace(db);
+	bumpGeneration(key, db);
+	if (tenantId !== null && tenantId !== void 0) {
+		promptCache.delete(buildCacheKey(key, tenantId, db));
+		return;
+	}
+	const keyPrefix = `${dbNamespace}::${key}::`;
+	for (const cacheKey of promptCache.keys()) if (cacheKey.startsWith(keyPrefix)) promptCache.delete(cacheKey);
+}
+var DEFAULT_EDITABLE = {
+	template: false,
+	profile: false,
+	model: false,
+	params: false
+};
+var TOP_LEVEL_RESERVED_KEYS = /* @__PURE__ */ new Set([
+	"key",
+	"editable",
+	"template",
+	"ai",
+	"profile",
+	"provider",
+	"model",
+	"params",
+	"temperature",
+	"maxTokens"
+]);
+var AI_RESERVED_KEYS = /* @__PURE__ */ new Set([
+	"profile",
+	"provider",
+	"model",
+	"params",
+	"temperature",
+	"maxTokens"
+]);
+var AI_ROUTING_PARAM_KEYS = /* @__PURE__ */ new Set([
+	"profile",
+	"provider",
+	"type",
+	"model",
+	"defaultModel"
+]);
+function isPlainObject(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeEditableConfig(editable) {
+	return {
+		template: editable?.template ?? DEFAULT_EDITABLE.template,
+		profile: editable?.profile ?? DEFAULT_EDITABLE.profile,
+		model: editable?.model ?? DEFAULT_EDITABLE.model,
+		params: editable?.params ?? DEFAULT_EDITABLE.params
+	};
+}
+function extractPromptParams(source, reservedKeys) {
+	const params = {};
+	if (isPlainObject(source.params)) Object.assign(params, sanitizePromptParams(source.params));
+	if ("temperature" in source && source.temperature !== void 0) params.temperature = source.temperature;
+	if ("maxTokens" in source && source.maxTokens !== void 0) params.maxTokens = source.maxTokens;
+	for (const [key, value] of Object.entries(source)) {
+		if (reservedKeys.has(key) || value === void 0) continue;
+		assignPromptParam(params, key, value);
+	}
+	return params;
+}
+function assignPromptParam(params, key, value) {
+	if (AI_ROUTING_PARAM_KEYS.has(key) || value === void 0) return;
+	params[key] = value;
+}
+function sanitizePromptParams(params) {
+	const sanitized = {};
+	if (!params) return sanitized;
+	for (const [key, value] of Object.entries(params)) assignPromptParam(sanitized, key, value);
+	return sanitized;
+}
+function mergePromptParams(...paramLayers) {
+	const merged = {};
+	for (const layer of paramLayers) {
+		if (!layer) continue;
+		for (const [key, value] of Object.entries(layer)) assignPromptParam(merged, key, value);
+	}
+	return merged;
+}
+function normalizeAIInput(ai) {
+	if (!isPlainObject(ai)) return { params: {} };
+	const profile = typeof ai.profile === "string" || ai.profile === null ? ai.profile : void 0;
+	const model = typeof ai.model === "string" || ai.model === null ? ai.model : void 0;
+	return {
+		profile: profile ?? void 0,
+		model: model ?? void 0,
+		params: extractPromptParams(ai, AI_RESERVED_KEYS)
+	};
+}
+function normalizePromptDefinitionInput(input) {
+	return {
+		key: input.key,
+		template: input.template,
+		ai: normalizeAIInput(input.ai),
+		editable: normalizeEditableConfig(input.editable)
+	};
+}
+function normalizePromptLayer(input) {
+	if (!isPlainObject(input)) return {};
+	const nestedAi = isPlainObject(input.ai) ? normalizeAIInput(input.ai) : { params: {} };
+	const topLevelParams = extractPromptParams(input, TOP_LEVEL_RESERVED_KEYS);
+	return {
+		template: input.template === void 0 ? void 0 : input.template === null ? null : String(input.template),
+		profile: input.profile === void 0 ? nestedAi.profile : input.profile === null ? null : String(input.profile),
+		model: input.model === void 0 ? nestedAi.model : input.model === null ? null : String(input.model),
+		params: mergePromptParams(topLevelParams, nestedAi.params)
+	};
+}
+function mergePromptLayers(...layers) {
+	let template = "";
+	let profile;
+	let model;
+	let params = {};
+	for (const layer of layers) {
+		if (!layer) continue;
+		if (layer.template !== void 0 && layer.template !== null) template = layer.template;
+		if (layer.profile !== void 0 && layer.profile !== null) profile = layer.profile;
+		if (layer.model !== void 0 && layer.model !== null) model = layer.model;
+		if (layer.params !== void 0 && layer.params !== null) params = mergePromptParams(params, layer.params);
+	}
+	return {
+		template,
+		ai: {
+			profile,
+			model,
+			params
+		}
+	};
+}
+function normalizeProfileConfig(profile) {
+	const params = extractPromptParams(isPlainObject(profile) ? profile : {}, /* @__PURE__ */ new Set(["provider", "model"]));
+	return {
+		provider: String(profile.provider),
+		model: String(profile.model),
+		params
+	};
+}
+function validateProfileName(profileName, config) {
+	if (profileName.trim() === "") throw new Error("Prompt profile names cannot be empty");
+	const allowedProfileNames = config.allowedProfileNames;
+	if (Array.isArray(allowedProfileNames) && !allowedProfileNames.includes(profileName)) throw new Error(`Prompt profile "${profileName}" is not in the allowed profile list`);
+	if (!config.profiles?.[profileName]) throw new Error(`Prompt profile "${profileName}" is not configured`);
+}
+function validateModelName(modelName, config) {
+	if (modelName.trim() === "") throw new Error("Prompt model overrides cannot be empty");
+	const allowedModels = config.allowedModels;
+	if (Array.isArray(allowedModels) && !allowedModels.includes(modelName)) throw new Error(`Prompt model "${modelName}" is not in the allowed model list`);
+}
+function buildResolvedAI(ai, config) {
+	let provider;
+	let model = ai.model;
+	let params = ai.params;
+	if (ai.profile) {
+		validateProfileName(ai.profile, config);
+		const configuredProfile = config.profiles?.[ai.profile];
+		if (!configuredProfile) throw new Error(`Prompt profile "${ai.profile}" is not configured`);
+		const profileConfig = normalizeProfileConfig(configuredProfile);
+		provider = profileConfig.provider;
+		model = model ?? profileConfig.model;
+		params = mergePromptParams(profileConfig.params, params);
+	}
+	if (ai.model) validateModelName(ai.model, config);
+	if (ai.model && !ai.profile) throw new Error("Direct prompt model overrides require an effective prompt profile");
+	if (model && !ai.model && config.allowedModels) validateModelName(model, config);
+	const resolved = {
+		...params,
+		profile: ai.profile,
+		provider,
+		model,
+		...config.allowedModels ? { allowedModels: [...config.allowedModels] } : {},
+		params
+	};
+	if (typeof params.temperature === "number") resolved.temperature = params.temperature;
+	if (typeof params.maxTokens === "number") resolved.maxTokens = params.maxTokens;
+	return resolved;
+}
+function renderPromptTemplate(template, variables) {
+	if (!variables || Object.keys(variables).length === 0) return template;
+	return template.replace(/\{([^{}]+)\}/g, (_match, rawKey) => {
+		const value = variables[rawKey.trim()];
+		if (value === void 0 || value === null) return "";
+		if (value instanceof Date) return value.toISOString();
+		if (Array.isArray(value) || isPlainObject(value)) try {
+			return JSON.stringify(value);
+		} catch {
+			return "";
+		}
+		return String(value);
+	});
+}
+function parsePromptParams(raw) {
+	if (!raw) return {};
+	try {
+		const parsed = JSON.parse(raw);
+		return isPlainObject(parsed) ? sanitizePromptParams(parsed) : {};
+	} catch {
+		return {};
+	}
+}
+function serializePromptParams(params) {
+	if (params === null || params === void 0) return null;
+	return JSON.stringify(sanitizePromptParams(params));
+}
+function getRegistry() {
+	if (!globalThis.__smrtPromptRegistry) globalThis.__smrtPromptRegistry = /* @__PURE__ */ new Map();
+	return globalThis.__smrtPromptRegistry;
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+var PromptRegistry = {
+	register(input) {
+		if (!input.key || input.key.trim() === "") throw new Error("Prompt definitions require a non-empty key");
+		const definition = normalizePromptDefinitionInput(input);
+		const registry = getRegistry();
+		const existing = registry.get(definition.key);
+		if (existing) {
+			if (stableStringify(existing) !== stableStringify(definition)) throw new Error(`Prompt "${definition.key}" is already registered with a different definition`);
+			return existing;
+		}
+		registry.set(definition.key, definition);
+		return definition;
+	},
+	get(key) {
+		return getRegistry().get(key);
+	},
+	has(key) {
+		return getRegistry().has(key);
+	},
+	getAll() {
+		return Array.from(getRegistry().values());
+	},
+	clear() {
+		getRegistry().clear();
+	}
+};
+function definePrompt(input) {
+	return PromptRegistry.register(input);
+}
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+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;
+};
+function getPromptConfig$1() {
+	return getPackageConfig("prompts", {
+		profiles: {},
+		prompts: {}
+	});
+}
+var PromptOverride = class extends SmrtObject {
+	key = "";
+	tenantId = null;
+	template = null;
+	profile = null;
+	model = null;
+	params = null;
+	constructor(options = {}) {
+		super(options);
+		if (options.key !== void 0) this.key = options.key;
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.template !== void 0) this.template = options.template;
+		if (options.profile !== void 0) this.profile = options.profile;
+		if (options.model !== void 0) this.model = options.model;
+		if (options.params !== void 0) if (typeof options.params === "string" || options.params === null) this.params = options.params;
+		else this.params = serializePromptParams(options.params);
+	}
+	getParams() {
+		return parsePromptParams(this.params);
+	}
+	setParams(params) {
+		this.params = serializePromptParams(params);
+	}
+	toPromptLayer() {
+		return {
+			template: this.template,
+			profile: this.profile,
+			model: this.model,
+			params: this.params === null ? null : this.getParams()
+		};
+	}
+	async save() {
+		const previousIdentity = await this.getPersistedIdentity();
+		this.normalizeParamsForPersistence();
+		await this.validatePromptOverride();
+		this.context = this.tenantId ?? "__app__";
+		const identityChanged = previousIdentity && (previousIdentity.key !== this.key || previousIdentity.tenantId !== this.tenantId);
+		const result = identityChanged && previousIdentity ? await this.saveAfterIdentityChange() : await super.save();
+		if (identityChanged && previousIdentity) invalidatePromptCache(previousIdentity.key, previousIdentity.tenantId, this.db);
+		invalidatePromptCache(this.key, this.tenantId, this.db);
+		return result;
+	}
+	async saveAfterIdentityChange() {
+		if (typeof this.db.beginTransaction === "function") return this.saveAfterIdentityChangeInTransaction();
+		return this.saveAfterIdentityChangeWithDeferredDelete();
+	}
+	async saveAfterIdentityChangeInTransaction() {
+		const originalDb = this._db;
+		const originalOptionsDb = this.options.db;
+		const tx = await this.db.beginTransaction?.();
+		if (!tx) return this.saveAfterIdentityChangeWithDeferredDelete();
+		try {
+			this._db = tx;
+			this.options.db = tx;
+			await super.delete();
+			const result = await super.save();
+			await tx.commit();
+			return result;
+		} catch (error) {
+			try {
+				await tx.rollback();
+			} catch {}
+			throw error;
+		} finally {
+			this._db = originalDb;
+			this.options.db = originalOptionsDb;
+		}
+	}
+	async saveAfterIdentityChangeWithDeferredDelete() {
+		const previousId = this.id;
+		if (!previousId) return super.save();
+		const replacementId = crypto.randomUUID();
+		let replacementSaved = false;
+		this.id = replacementId;
+		try {
+			const result = await super.save();
+			replacementSaved = true;
+			await this.db.delete(this.tableName, { id: previousId });
+			return result;
+		} catch (error) {
+			if (replacementSaved) try {
+				await this.db.delete(this.tableName, { id: replacementId });
+			} catch {}
+			this.id = previousId;
+			throw error;
+		}
+	}
+	async delete() {
+		const key = this.key;
+		const tenantId = this.tenantId;
+		await super.delete();
+		invalidatePromptCache(key, tenantId, this.db);
+	}
+	async validatePromptOverride() {
+		if (!this.key || this.key.trim() === "") throw new Error("PromptOverride.key is required");
+		const definition = PromptRegistry.get(this.key);
+		if (!definition) throw new Error(`Unknown prompt key "${this.key}"`);
+		const config = getPromptConfig$1();
+		const editable = definition.editable;
+		if (this.template !== null && !editable.template) throw new Error(`Prompt "${this.key}" does not allow template overrides`);
+		if (this.profile !== null && !editable.profile) throw new Error(`Prompt "${this.key}" does not allow profile overrides`);
+		if (this.model !== null && !editable.model) throw new Error(`Prompt "${this.key}" does not allow model overrides`);
+		if (this.params !== null && !editable.params) throw new Error(`Prompt "${this.key}" does not allow params overrides`);
+		if (this.params !== null) try {
+			const parsed = JSON.parse(this.params);
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Prompt params must be a JSON object");
+		} catch (error) {
+			throw new Error(`Prompt "${this.key}" has invalid params JSON: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (this.profile !== null) validateProfileName(this.profile, config);
+		if (this.model !== null) validateModelName(this.model, config);
+		const lowerLayers = await this.getLowerPrecedenceLayers();
+		const currentLayer = this.toPromptLayer();
+		const merged = mergePromptLayers(...lowerLayers, currentLayer);
+		if (currentLayer.model && !merged.ai.profile) throw new Error(`Prompt "${this.key}" model overrides require an effective prompt profile`);
+	}
+	async getLowerPrecedenceLayers() {
+		const definition = PromptRegistry.get(this.key);
+		const config = getPromptConfig$1();
+		const layers = [];
+		if (definition) layers.push({
+			template: definition.template,
+			profile: definition.ai.profile ?? null,
+			model: definition.ai.model ?? null,
+			params: definition.ai.params
+		});
+		layers.push(normalizePromptLayer(config.prompts?.[this.key]));
+		const { PromptOverrideCollection } = await Promise.resolve().then(() => PromptOverrideCollection_exports);
+		const collection = await PromptOverrideCollection.create({ db: this.options.db ?? this.options.persistence });
+		if (this.tenantId) {
+			const appOverride = await collection.getAppOverride(this.key, { excludeId: this.id ?? void 0 });
+			if (appOverride) layers.push(appOverride.toPromptLayer());
+		}
+		return layers;
+	}
+	normalizeParamsForPersistence() {
+		const rawParams = this.params;
+		if (rawParams === null || rawParams === void 0) {
+			this.params = null;
+			return;
+		}
+		if (typeof rawParams === "string") {
+			this.params = rawParams;
+			return;
+		}
+		if (typeof rawParams === "object" && !Array.isArray(rawParams)) {
+			this.params = serializePromptParams(rawParams);
+			return;
+		}
+		throw new Error(`Prompt "${this.key}" params must be a JSON object or JSON string`);
+	}
+	async getPersistedIdentity() {
+		if (!this.id) return null;
+		const existing = await this.db.get(this.tableName, { id: this.id });
+		if (!existing) return null;
+		return {
+			key: String(existing.key ?? this.key),
+			tenantId: existing.tenantId !== void 0 ? existing.tenantId : existing.tenant_id ?? null
+		};
+	}
+};
+__decorateClass$3([field({ required: true })], PromptOverride.prototype, "key", 2);
+__decorateClass$3([field({
+	type: "text",
+	nullable: true
+})], PromptOverride.prototype, "tenantId", 2);
+__decorateClass$3([field({
+	type: "text",
+	nullable: true
+})], PromptOverride.prototype, "template", 2);
+__decorateClass$3([field({
+	type: "text",
+	nullable: true
+})], PromptOverride.prototype, "profile", 2);
+__decorateClass$3([field({
+	type: "text",
+	nullable: true
+})], PromptOverride.prototype, "model", 2);
+__decorateClass$3([field({
+	type: "text",
+	nullable: true
+})], PromptOverride.prototype, "params", 2);
+PromptOverride = __decorateClass$3([smrt({
+	tableName: "_smrt_prompt_overrides",
+	conflictColumns: ["key", "context"],
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update",
+		"delete"
+	] },
+	cli: {
+		include: [
+			"list",
+			"get",
+			"create",
+			"update",
+			"delete"
+		],
+		exclude: [
+			"getParams",
+			"setParams",
+			"toPromptLayer"
+		]
+	},
+	mcp: { include: [] }
+})], PromptOverride);
+var PromptOverrideCollection_exports = /* @__PURE__ */ __exportAll({ PromptOverrideCollection: () => PromptOverrideCollection });
+var PromptOverrideCollection = class extends SmrtCollection {
+	static _itemClass = PromptOverride;
+	excludeOverrideId(items, excludeId) {
+		return items.filter((item) => excludeId ? item.id !== excludeId : true);
+	}
+	async getAppOverride(key, options = {}) {
+		const items = await this.list({ where: {
+			key,
+			tenantId: null
+		} });
+		return this.excludeOverrideId(items, options.excludeId)[0] ?? null;
+	}
+	async getTenantOverride(key, tenantId, options = {}) {
+		const items = await this.list({ where: {
+			key,
+			tenantId
+		} });
+		return this.excludeOverrideId(items, options.excludeId)[0] ?? null;
+	}
+	async getResolutionLayers(key, tenantId, options = {}) {
+		const [app, tenant] = await Promise.all([this.getAppOverride(key, options), tenantId != null ? this.getTenantOverride(key, tenantId, options) : Promise.resolve(null)]);
+		return {
+			app,
+			tenant
+		};
+	}
+};
+function getPromptConfig() {
+	return getPackageConfig("prompts", {
+		profiles: {},
+		prompts: {}
+	});
+}
+async function loadPromptBase(key, options) {
+	const definition = PromptRegistry.get(key);
+	if (!definition) throw new Error(`Unknown prompt key "${key}"`);
+	const tenantId = options.tenantId !== void 0 ? options.tenantId : getTenantId() ?? null;
+	let collection = null;
+	let cacheDb = options.db;
+	if (options.db) {
+		const initializedCollection = await PromptOverrideCollection.create({ db: options.db });
+		collection = initializedCollection;
+		cacheDb = initializedCollection.db;
+	}
+	const cached = getCachedPromptBase(key, tenantId, cacheDb);
+	if (cached) return cached;
+	const loadedAtGeneration = getPromptCacheGeneration(key, cacheDb);
+	const config = getPromptConfig();
+	const layers = [{
+		template: definition.template,
+		profile: definition.ai.profile ?? null,
+		model: definition.ai.model ?? null,
+		params: definition.ai.params
+	}, normalizePromptLayer(config.prompts?.[key])];
+	if (collection) {
+		const stored = await collection.getResolutionLayers(key, tenantId);
+		if (stored.app) layers.push(stored.app.toPromptLayer());
+		if (stored.tenant) layers.push(stored.tenant.toPromptLayer());
+	}
+	const merged = mergePromptLayers(...layers);
+	const value = {
+		key,
+		template: merged.template,
+		ai: merged.ai
+	};
+	setCachedPromptBase(key, tenantId, cacheDb, value, loadedAtGeneration);
+	return value;
+}
+async function resolvePrompt(key, options = {}) {
+	const config = getPromptConfig();
+	const base = await loadPromptBase(key, options);
+	const runtimeOverride = normalizePromptLayer(options.override);
+	const merged = mergePromptLayers({
+		template: base.template,
+		profile: base.ai.profile ?? null,
+		model: base.ai.model ?? null,
+		params: base.ai.params
+	}, runtimeOverride);
+	return {
+		key,
+		template: merged.template,
+		text: renderPromptTemplate(merged.template, options.variables),
+		ai: buildResolvedAI(merged.ai, config)
+	};
+}
+//#endregion
+//#region ../profiles/dist/chunks/ProfileCollection-BvhD2cfL.js
+var ProfileCollection_BvhD2cfL_exports = /* @__PURE__ */ __exportAll$1({
+	_: () => smrtProfilesGenerateBioPrompt,
+	a: () => Profile,
+	d: () => isOidcProvisioningRaceConflict,
+	f: () => saveOidcRaceArbiter,
+	g: () => promptMessageOptions,
+	h: () => ProfileType_exports,
+	i: () => OidcProfileEmailReservationCollection,
+	l: () => coordinateOidcProvisioning,
+	m: () => ProfileType,
+	n: () => ProfileCollection,
+	o: () => OidcProfileEmailReservation,
+	p: () => normalizeIdentityEmail,
+	r: () => ProfileCollection_exports,
+	s: () => PROFILE_EMAIL_KEY_BACKFILL_NAME,
+	t: () => CanonicalPersonProfileError,
+	u: () => isOidcAbortedTransactionError
+});
+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 } : {}
+	};
+}
+var ProfileType_exports = /* @__PURE__ */ __exportAll$2({ ProfileType: () => ProfileType });
+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 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$2([tenantId({ nullable: true })], ProfileType.prototype, "tenantId", 2);
+__decorateClass$2([field({ required: true })], ProfileType.prototype, "name", 2);
+ProfileType = __decorateClass$2([TenantScoped({ mode: "optional" }), smrt({
+	tableStrategy: "sti",
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: { skipApiCheck: true }
+})], ProfileType);
+function normalizeIdentityEmail(email) {
+	const normalized = email.trim().toLowerCase();
+	if (!normalized) throw new Error("Identity email normalization requires a non-blank email.");
+	return normalized;
+}
+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";
+	return withProvisioningLocks(options.db, options.lockKeys, async () => {
+		if (rootBackfillTableReady) await new BackfillTracker({ db: options.db }).initialize();
+		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) {
+	return isAbortedTransactionError(error);
+}
+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;
+	}
+}
+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 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$1([foreignKey("Profile", {
+	required: true,
+	unique: true
+})], OidcProfileEmailReservation.prototype, "profileId", 2);
+__decorateClass$1([field({
+	type: "text",
+	required: true,
+	unique: true,
+	readonly: true
+})], OidcProfileEmailReservation.prototype, "emailKey", 2);
+OidcProfileEmailReservation = __decorateClass$1([smrt({
+	tableName: "oidc_profile_email_reservations",
+	api: false,
+	mcp: false,
+	cli: false
+})], OidcProfileEmailReservation);
+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-CMKhVi2I--ba-T4qA.js").then((n) => n.n);
+		const { ProfileMetadataCollection } = await import("./ProfileMetadataCollection-DxX_BJKV-StatXt-E.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-DxX_BJKV-StatXt-E.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-CMKhVi2I--ba-T4qA.js").then((n) => n.n);
+		const { ProfileMetadataCollection } = await import("./ProfileMetadataCollection-DxX_BJKV-StatXt-E.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-V8u4wqSL-BKz6v8py.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-BdXwd7Kf-GEu0alx6.js").then((n) => n.n);
+		const { ProfileRelationshipCollection } = await import("./ProfileRelationshipCollection-DUVgaIqf-B4TDc4TQ.js").then((n) => n.n);
+		const { ProfileRelationshipType } = await import("./ProfileRelationshipType-BRiRka6t-Dw1efEX5.js").then((n) => n.n).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-DUVgaIqf-B4TDc4TQ.js").then((n) => n.n);
+		const { ProfileRelationshipTypeCollection } = await import("./ProfileRelationshipTypeCollection-BdXwd7Kf-GEu0alx6.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-BdXwd7Kf-GEu0alx6.js").then((n) => n.n);
+		const { ProfileRelationshipCollection } = await import("./ProfileRelationshipCollection-DUVgaIqf-B4TDc4TQ.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-Bfb_nw81-Dks_0546.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-Bfb_nw81-Dks_0546.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-BZmbOTnL-Dz-PO2sa.js").then((n) => n.n).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-D3L0WYbM-C85jz9CB.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-D3L0WYbM-C85jz9CB.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-Ca74dkaL-DESXyrjY.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-Ca74dkaL-DESXyrjY.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-B1YonCAP-Db9tLDtf.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-B1YonCAP-Db9tLDtf.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({
+	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: { skipApiCheck: true }
+})], Profile);
+var OidcProfileEmailReservationCollection = class extends SmrtCollection {
+	static _itemClass = OidcProfileEmailReservation;
+};
+var ProfileCollection_exports = /* @__PURE__ */ __exportAll$2({
+	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 CAST(id AS VARCHAR) AS 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 CAST(id AS VARCHAR) AS 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.`);
+		profile.id = profileId;
+		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 { coordinateOidcProvisioning as a, saveOidcRaceArbiter as c, ProfileType as i, ProfileCollection as n, isOidcProvisioningRaceConflict as o, ProfileCollection_BvhD2cfL_exports as r, normalizeIdentityEmail as s, Profile as t };