@happyvertical/smrt-profiles 0.30.0

package/dist/chunks/ProfileCollection-DU6wUJTO.js

@@ -0,0 +1,782 @@
+import { resolveOwnedAssetsById, assertValidOwnedAssetRelationship, assertValidOwnedAssetSortOrder, getOwnedAssetsFromCollection, addOwnedAssetFromCollection, removeOwnedAssetFromCollection } from "@happyvertical/smrt-assets";
+import { field, smrt, SmrtObject, foreignKey, oneToMany, SmrtCollection } from "@happyvertical/smrt-core";
+import { definePrompt, resolvePrompt } from "@happyvertical/smrt-prompts";
+import { tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+const 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 __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;
+};
+let 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);
+const ProfileType$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get ProfileType() {
+    return ProfileType;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+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;
+};
+let Profile = class extends SmrtObject {
+  tenantId = null;
+  typeId;
+  email;
+  name = "";
+  // Display 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() {
+    const type = await this.loadRelated("typeId");
+    return type?.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-DMKhSHXX.js").then((n) => n.b);
+    const { ProfileMetadataCollection } = await import("./ProfileMetadataCollection-DEhmljMY.js").then((n) => n.b);
+    const metafieldCollection = await ProfileMetafieldCollection.create(this.options);
+    const metafield = await metafieldCollection.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 {
+      const metadata = await metadataCollection.create({
+        profileId: this.id,
+        metafieldId: metafield.id,
+        value: String(value)
+      });
+      await metadata.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-DEhmljMY.js").then((n) => n.b);
+    const metadataCollection = await ProfileMetadataCollection.create(
+      this.options
+    );
+    return await metadataCollection.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-DMKhSHXX.js").then((n) => n.b);
+    const { ProfileMetadataCollection } = await import("./ProfileMetadataCollection-DEhmljMY.js").then((n) => n.b);
+    const metafieldCollection = await ProfileMetafieldCollection.create(this.options);
+    const metafield = await metafieldCollection.getBySlug(metafieldSlug);
+    if (!metafield) {
+      throw new Error(`Metafield '${metafieldSlug}' not found`);
+    }
+    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) {
+      await existing[0].delete();
+    }
+  }
+  async getProfileAssetCollection() {
+    const { ProfileAssetCollection } = await import("./ProfileAssetCollection-D_tk1kKG.js").then((n) => n.b);
+    return ProfileAssetCollection.create({ db: this.db });
+  }
+  async getAssets(relationship) {
+    if (!this.id) {
+      return [];
+    }
+    const profileAssets = await this.getProfileAssetCollection();
+    const linkedAssets = await profileAssets.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);
+    const profileAssets = await this.getProfileAssetCollection();
+    await profileAssets.attach(this.id, asset.id, {
+      relationship,
+      sortOrder,
+      tenantId: this.tenantId
+    });
+  }
+  async removeAsset(assetId, relationship) {
+    if (!this.id) {
+      return;
+    }
+    const profileAssets = await this.getProfileAssetCollection();
+    await profileAssets.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-CF8YvLTV.js");
+    const { ProfileRelationshipCollection } = await import("./ProfileRelationshipCollection-C0IM8UQR.js").then((n) => n.b);
+    const { ProfileRelationshipType } = await import("./ProfileRelationshipType-BXBLldea.js");
+    const relationshipTypeCollection = await ProfileRelationshipTypeCollection.create(this.options);
+    const relationshipType = await relationshipTypeCollection.getBySlug(relationshipSlug);
+    if (!relationshipType) {
+      throw new Error(`Relationship type '${relationshipSlug}' not found`);
+    }
+    const relationshipCollection = await ProfileRelationshipCollection.create(this.options);
+    const exists = await relationshipCollection.exists(
+      this.id,
+      toProfile.id,
+      relationshipType.id
+    );
+    if (!exists) {
+      const relationship = await relationshipCollection.create({
+        fromProfileId: this.id,
+        toProfileId: toProfile.id,
+        typeId: relationshipType.id,
+        contextProfileId: contextProfile?.id
+      });
+      await relationship.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-C0IM8UQR.js").then((n) => n.b);
+    const { ProfileRelationshipTypeCollection } = await import("./ProfileRelationshipTypeCollection-CF8YvLTV.js");
+    const relationshipCollection = await ProfileRelationshipCollection.create(this.options);
+    const direction = options?.direction || "all";
+    let typeId;
+    if (options?.typeSlug) {
+      const relationshipTypeCollection = await ProfileRelationshipTypeCollection.create(this.options);
+      const relationshipType = await relationshipTypeCollection.getBySlug(
+        options.typeSlug
+      );
+      typeId = relationshipType?.id;
+    }
+    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: ProfileCollection2 } = await Promise.resolve().then(() => ProfileCollection$1);
+    const relationships = await this.getRelationships({
+      typeSlug: relationshipSlug,
+      direction: "all"
+    });
+    const profileCollection = await ProfileCollection2.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 thisId = String(this.id);
+      const otherId = fromId === thisId ? 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-CF8YvLTV.js");
+    const { ProfileRelationshipCollection } = await import("./ProfileRelationshipCollection-C0IM8UQR.js").then((n) => n.b);
+    const relationshipTypeCollection = await ProfileRelationshipTypeCollection.create(this.options);
+    const relationshipType = await relationshipTypeCollection.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 || ""
+        }
+      }
+    );
+    const ai = await this.getAiClient();
+    const response = await ai.message(
+      resolvedPrompt.text,
+      promptMessageOptions(resolvedPrompt.ai)
+    );
+    return response.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;
+  }
+  // ========================
+  // Auth-related methods
+  // ========================
+  /**
+   * Get all API keys for this profile
+   *
+   * @returns Array of API keys
+   */
+  async getApiKeys() {
+    const { ApiKeyCollection } = await import("./ApiKeyCollection-B6Op817e.js");
+    const collection = await ApiKeyCollection.create(this.options);
+    return await collection.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-B6Op817e.js");
+    const collection = await ApiKeyCollection.create(this.options);
+    return await collection.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-B2LKEaP8.js");
+    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("./index-jFtOWsAV.js").then((n) => n.j);
+    const collection = await OidcIdentityCollection.create(
+      this.options
+    );
+    return await collection.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("./index-jFtOWsAV.js").then((n) => n.j);
+    const collection = await OidcIdentityCollection.create(
+      this.options
+    );
+    return await collection.linkToProfile(this, oidcData);
+  }
+  /**
+   * Get all Nostr identities linked to this profile
+   *
+   * @returns Array of Nostr identity records
+   */
+  async getNostrIdentities() {
+    const { NostrIdentityCollection } = await import("./NostrIdentityCollection-DadQBHWy.js").then((n) => n.q);
+    const collection = await NostrIdentityCollection.create(
+      this.options
+    );
+    return await collection.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-DadQBHWy.js").then((n) => n.q);
+    const collection = await NostrIdentityCollection.create(
+      this.options
+    );
+    return await collection.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-BYqCj0uE.js").then((n) => n.b);
+    const collection = await AuditLogCollection.create(this.options);
+    return await collection.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-BYqCj0uE.js").then((n) => n.b);
+    const collection = await AuditLogCollection.create(this.options);
+    return await collection.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);
+class ProfileCollection 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) {
+      const slug = await profile.getTypeSlug();
+      if (slug === 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;
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Tenant-scoped helper methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * 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(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global profiles (without a tenant)
+   *
+   * @returns Array of profiles with null tenantId
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find profiles belonging to a tenant plus all global profiles
+   *
+   * @param tenantId - The tenant UUID to include
+   * @returns Array of tenant-specific and global profiles
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const ProfileCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ProfileCollection
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  ProfileType as P,
+  Profile as a,
+  ProfileCollection as b,
+  ProfileType$1 as c,
+  ProfileCollection$1 as d,
+  promptMessageOptions as p,
+  smrtProfilesGenerateBioPrompt as s
+};
+//# sourceMappingURL=ProfileCollection-DU6wUJTO.js.map