@happyvertical/smrt-profiles 0.37.2 → 0.37.3

package/dist/chunks/ProfileCollection-DlhdOnDr.js

@@ -0,0 +1,641 @@
+import { x as __exportAll } from "./NostrIdentityCollection-CG6HGf6c.js";
+import { SmrtCollection, SmrtObject, field, foreignKey, oneToMany, smrt } from "@happyvertical/smrt-core";
+import { definePrompt, resolvePrompt } from "@happyvertical/smrt-prompts";
+import { TenantScoped, queryGlobal, queryWithGlobals, tenantId } from "@happyvertical/smrt-tenancy";
+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/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;
+	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;
+	}
+	/**
+	* 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-C8TX9HvN.js").then((n) => n.n);
+		const { ProfileMetadataCollection } = await import("./ProfileMetadataCollection-CGcO4Iw_.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-CGcO4Iw_.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-C8TX9HvN.js").then((n) => n.n);
+		const { ProfileMetadataCollection } = await import("./ProfileMetadataCollection-CGcO4Iw_.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-BY2Wbem3.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-CQu08kxF.js").then((n) => n.n);
+		const { ProfileRelationshipCollection } = await import("./ProfileRelationshipCollection-JnskbZTd.js").then((n) => n.n);
+		const { ProfileRelationshipType } = await import("./ProfileRelationshipType-OMBn5cWR.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-JnskbZTd.js").then((n) => n.n);
+		const { ProfileRelationshipTypeCollection } = await import("./ProfileRelationshipTypeCollection-CQu08kxF.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-CQu08kxF.js").then((n) => n.n);
+		const { ProfileRelationshipCollection } = await import("./ProfileRelationshipCollection-JnskbZTd.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-PwVs0qDb.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-PwVs0qDb.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-3DlNEc91.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-DiLneB7J.js").then((n) => n.n);
+		return await (await OidcIdentityCollection.create(this.options)).findByProfile(this.id);
+	}
+	/**
+	* Link a new OIDC identity to this profile
+	*
+	* @param oidcData - OIDC provider data
+	* @returns The linked OIDC identity record
+	*/
+	async linkOidcIdentity(oidcData) {
+		const { OidcIdentityCollection } = await import("./OidcIdentityCollection-DiLneB7J.js").then((n) => n.n);
+		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-CG6HGf6c.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-CG6HGf6c.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-CnIYU0aK.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-CnIYU0aK.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({ 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/ProfileCollection.ts
+var ProfileCollection_exports = /* @__PURE__ */ __exportAll({ ProfileCollection: () => ProfileCollection });
+var ProfileCollection = class extends SmrtCollection {
+	static _itemClass = Profile;
+	/**
+	* 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 = email.toLowerCase();
+		const profiles = await this.list({
+			where: { email: normalizedEmail },
+			limit: 1
+		});
+		return profiles.length > 0 ? profiles[0] : null;
+	}
+	/**
+	* 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;
+	}
+	/**
+	* 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");
+	}
+};
+//#endregion
+export { ProfileType_exports as a, ProfileType as i, ProfileCollection_exports as n, promptMessageOptions as o, Profile as r, smrtProfilesGenerateBioPrompt as s, ProfileCollection as t };
+
+//# sourceMappingURL=ProfileCollection-DlhdOnDr.js.map