@happyvertical/smrt-events 0.30.0

package/dist/index.js

@@ -0,0 +1,1419 @@
+import { ObjectRegistry, foreignKey, crossPackageRef, field, smrt, SmrtObject, SmrtJunction, SmrtHierarchical, SmrtCollection } from "@happyvertical/smrt-core";
+import { getOwnedAssetsFromCollection, addOwnedAssetFromCollection, removeOwnedAssetFromCollection, resolveOwnedAssetsById, assertValidOwnedAssetRelationship, assertValidOwnedAssetSortOrder } from "@happyvertical/smrt-assets";
+import { tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+import { EVENTS_MODULE_META, EVENTS_UI_SLOTS } from "./ui.js";
+import { calculateDuration, calculateNextOccurrence, checkSchedulingConflict, formatDuration, formatEventDateRange, generateEventSlug, getEventStatusFromDates, isEventNow, parseRecurrencePattern, sortEventsByDate, validateEventStatus } from "./utils.js";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __decorateClass$6 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(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$6(target, key, result);
+  return result;
+};
+let EventAsset = class extends SmrtObject {
+  tenantId = null;
+  eventId = "";
+  assetId = "";
+  relationship = "attachment";
+  sortOrder = 0;
+  constructor(options = {}) {
+    super(options);
+    if (options.eventId) this.eventId = options.eventId;
+    if (options.assetId) this.assetId = options.assetId;
+    if (options.relationship) this.relationship = options.relationship;
+    if (options.sortOrder !== void 0) this.sortOrder = options.sortOrder;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+};
+__decorateClass$6([
+  tenantId({ nullable: true })
+], EventAsset.prototype, "tenantId", 2);
+__decorateClass$6([
+  foreignKey("Event", { required: true })
+], EventAsset.prototype, "eventId", 2);
+__decorateClass$6([
+  crossPackageRef("@happyvertical/smrt-assets:Asset", { required: true })
+], EventAsset.prototype, "assetId", 2);
+__decorateClass$6([
+  field({ required: true })
+], EventAsset.prototype, "relationship", 2);
+__decorateClass$6([
+  field()
+], EventAsset.prototype, "sortOrder", 2);
+EventAsset = __decorateClass$6([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableName: "event_assets",
+    conflictColumns: ["event_id", "asset_id", "relationship"],
+    api: false,
+    mcp: false,
+    cli: false
+  })
+], EventAsset);
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "", value);
+let EventAssetCollection = class extends SmrtJunction {
+  leftField = "eventId";
+  rightField = "assetId";
+  eventCollectionPromise = null;
+  async getEventCollection() {
+    if (!this.eventCollectionPromise) {
+      const { EventCollection: EventCollection2 } = await Promise.resolve().then(() => EventCollection$1);
+      this.eventCollectionPromise = EventCollection2.create({ db: this.db });
+    }
+    return this.eventCollectionPromise;
+  }
+  async getAssets(eventId, relationship) {
+    return getOwnedAssetsFromCollection(
+      await this.getEventCollection(),
+      eventId,
+      relationship
+    );
+  }
+  async addAsset(eventId, asset, relationship = "attachment", sortOrder = 0) {
+    await addOwnedAssetFromCollection(
+      await this.getEventCollection(),
+      "Event",
+      eventId,
+      asset,
+      relationship,
+      sortOrder
+    );
+  }
+  async removeAsset(eventId, assetId, relationship) {
+    await removeOwnedAssetFromCollection(
+      await this.getEventCollection(),
+      "Event",
+      eventId,
+      assetId,
+      relationship
+    );
+  }
+};
+__publicField$1(EventAssetCollection, "_itemClass", EventAsset);
+EventAssetCollection = __decorateClass$5([
+  smrt({
+    api: false,
+    mcp: false,
+    cli: false
+  })
+], EventAssetCollection);
+const EventAssetCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get EventAssetCollection() {
+    return EventAssetCollection;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(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$4(target, key, result);
+  return result;
+};
+let Event = class extends SmrtHierarchical {
+  tenantId = null;
+  name = "";
+  seriesId = "";
+  typeId = "";
+  placeId = "";
+  // FK to Place (from @happyvertical/smrt-places)
+  description = "";
+  startDate = null;
+  endDate = null;
+  status = "scheduled";
+  round = null;
+  // Sequence/round number in series
+  metadata = "";
+  // JSON metadata (stored as text)
+  externalId = "";
+  // External system identifier
+  source = "";
+  // Source system
+  // Timestamps
+  createdAt = /* @__PURE__ */ new Date();
+  updatedAt = /* @__PURE__ */ new Date();
+  constructor(options = {}) {
+    super(options);
+    if (options.seriesId !== void 0) this.seriesId = options.seriesId;
+    if (options.parentId !== void 0)
+      this.parentId = options.parentId ?? null;
+    if (options.typeId) this.typeId = options.typeId;
+    if (options.placeId !== void 0) this.placeId = options.placeId;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.startDate !== void 0)
+      this.startDate = options.startDate || null;
+    if (options.endDate !== void 0) this.endDate = options.endDate || null;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.round !== void 0) this.round = options.round;
+    if (options.externalId !== void 0) this.externalId = options.externalId;
+    if (options.source !== void 0) this.source = options.source;
+    if (options.metadata !== void 0) {
+      if (typeof options.metadata === "string") {
+        this.metadata = options.metadata;
+      } else {
+        this.metadata = JSON.stringify(options.metadata);
+      }
+    }
+    if (options.createdAt) this.createdAt = options.createdAt;
+    if (options.updatedAt) this.updatedAt = options.updatedAt;
+  }
+  /**
+   * Get metadata as parsed object
+   *
+   * @returns Parsed metadata object or empty object
+   */
+  getMetadata() {
+    if (!this.metadata) return {};
+    try {
+      return JSON.parse(this.metadata);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set metadata from object
+   *
+   * @param data - Metadata object to store
+   */
+  setMetadata(data) {
+    this.metadata = JSON.stringify(data);
+  }
+  /**
+   * Update metadata by merging with existing values
+   *
+   * @param updates - Partial metadata to merge
+   */
+  updateMetadata(updates) {
+    const current = this.getMetadata();
+    this.setMetadata({ ...current, ...updates });
+  }
+  /**
+   * Update event status
+   *
+   * @param newStatus - New status to set
+   */
+  async updateStatus(newStatus) {
+    this.status = newStatus;
+    this.updatedAt = /* @__PURE__ */ new Date();
+    await this.save();
+  }
+  /**
+   * Get the series for this event
+   *
+   * @returns EventSeries instance or null
+   */
+  async getSeries() {
+    if (!this.seriesId) return null;
+    const { EventSeriesCollection: EventSeriesCollection2 } = await Promise.resolve().then(() => EventSeriesCollection$1);
+    const collection = await EventSeriesCollection2.create(
+      this.options
+    );
+    return await collection.get({ id: this.seriesId });
+  }
+  /**
+   * Get the event type
+   *
+   * @returns EventType instance or null
+   */
+  async getType() {
+    if (!this.typeId) return null;
+    const { EventTypeCollection: EventTypeCollection2 } = await Promise.resolve().then(() => EventTypeCollection$1);
+    const collection = await EventTypeCollection2.create(this.options);
+    return await collection.get({ id: this.typeId });
+  }
+  /**
+   * Get the place for this event
+   *
+   * @returns Place instance or null
+   */
+  async getPlace() {
+    if (!this.placeId) return null;
+    try {
+      const { PlaceCollection } = await import("@happyvertical/smrt-places");
+      const collection = await PlaceCollection.create(this.options);
+      return await collection.get({ id: this.placeId });
+    } catch {
+      return null;
+    }
+  }
+  // Hierarchy traversal (getParent / getChildren / getAncestors /
+  // getDescendants / getHierarchy / moveTo) provided by SmrtHierarchical.
+  /**
+   * Get the root event (top-level ancestor) of this event's hierarchy.
+   *
+   * @returns Root event instance — `this` when already root
+   */
+  async getRootEvent() {
+    const ancestors = await this.getAncestors();
+    return ancestors.length > 0 ? ancestors[0] : this;
+  }
+  /**
+   * Get all participants for this event
+   *
+   * @returns Array of EventParticipant instances
+   */
+  async getParticipants() {
+    const { EventParticipantCollection: EventParticipantCollection2 } = await Promise.resolve().then(() => EventParticipantCollection$1);
+    const collection = await EventParticipantCollection2.create(
+      this.options
+    );
+    return await collection.list({ where: { eventId: this.id } });
+  }
+  async getEventAssetCollection() {
+    const { EventAssetCollection: EventAssetCollection2 } = await Promise.resolve().then(() => EventAssetCollection$1);
+    return EventAssetCollection2.create({ db: this.db });
+  }
+  async getAssets(relationship) {
+    if (!this.id) {
+      return [];
+    }
+    const eventAssets = await this.getEventAssetCollection();
+    const linkedAssets = await eventAssets.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 event or asset");
+    }
+    assertValidOwnedAssetRelationship(relationship);
+    assertValidOwnedAssetSortOrder(sortOrder);
+    const eventAssets = await this.getEventAssetCollection();
+    await eventAssets.attach(this.id, asset.id, {
+      relationship,
+      sortOrder,
+      tenantId: this.tenantId
+    });
+  }
+  async removeAsset(assetId, relationship) {
+    if (!this.id) {
+      return;
+    }
+    const eventAssets = await this.getEventAssetCollection();
+    await eventAssets.detach(
+      this.id,
+      assetId,
+      relationship ? { relationship } : {}
+    );
+  }
+  /**
+   * Check if event is currently in progress
+   *
+   * @returns True if current time is between start and end
+   */
+  isInProgress() {
+    if (this.status !== "in_progress") return false;
+    const now = /* @__PURE__ */ new Date();
+    if (this.startDate && now < this.startDate) return false;
+    if (this.endDate && now > this.endDate) return false;
+    return true;
+  }
+  /**
+   * Check if event is a root event (no parent)
+   *
+   * @returns True if parentId is null/empty
+   */
+  isRoot() {
+    return !this.parentId;
+  }
+};
+__decorateClass$4([
+  tenantId({ nullable: true })
+], Event.prototype, "tenantId", 2);
+__decorateClass$4([
+  foreignKey("EventSeries")
+], Event.prototype, "seriesId", 2);
+__decorateClass$4([
+  foreignKey("EventType")
+], Event.prototype, "typeId", 2);
+__decorateClass$4([
+  crossPackageRef("@happyvertical/smrt-places:Place")
+], Event.prototype, "placeId", 2);
+Event = __decorateClass$4([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get", "create", "update"] },
+    cli: true
+  })
+], Event);
+class EventCollection extends SmrtCollection {
+  static _itemClass = Event;
+  /**
+   * Get events by series
+   *
+   * @param seriesId - EventSeries ID
+   * @returns Array of Event instances
+   */
+  async getBySeriesId(seriesId) {
+    return await this.list({ where: { seriesId } });
+  }
+  /**
+   * Get events at a specific place
+   *
+   * @param placeId - Place ID
+   * @returns Array of Event instances
+   */
+  async getByPlace(placeId) {
+    return await this.list({ where: { placeId } });
+  }
+  /**
+   * Get events by date range
+   *
+   * @param startDate - Start of date range
+   * @param endDate - End of date range
+   * @returns Array of Event instances
+   */
+  async getByDateRange(startDate, endDate) {
+    const allEvents = await this.list({});
+    return allEvents.filter((event) => {
+      if (!event.startDate) return false;
+      return event.startDate >= startDate && event.startDate <= endDate;
+    });
+  }
+  /**
+   * Get upcoming events
+   *
+   * @param limit - Maximum number of events to return
+   * @returns Array of Event instances starting in the future
+   */
+  async getUpcoming(limit) {
+    const allEvents = await this.list({});
+    const now = /* @__PURE__ */ new Date();
+    const upcoming = allEvents.filter((event) => event.startDate && event.startDate > now).sort((a, b) => {
+      if (!a.startDate || !b.startDate) return 0;
+      return a.startDate.getTime() - b.startDate.getTime();
+    });
+    return limit ? upcoming.slice(0, limit) : upcoming;
+  }
+  /**
+   * Get events by status
+   *
+   * @param status - Event status to filter by
+   * @returns Array of Event instances
+   */
+  async getByStatus(status) {
+    return await this.list({ where: { status } });
+  }
+  /**
+   * Get events by type
+   *
+   * @param typeId - EventType ID
+   * @returns Array of Event instances
+   */
+  async getByType(typeId) {
+    return await this.list({ where: { typeId } });
+  }
+  /**
+   * Get root events (no parent)
+   *
+   * @returns Array of Event instances with no parent
+   */
+  async getRootEvents() {
+    const allEvents = await this.list({});
+    return allEvents.filter((event) => !event.parentId);
+  }
+  /**
+   * Get children of a parent event
+   *
+   * @param parentId - Parent event ID
+   * @returns Array of child Event instances
+   */
+  async getByParent(parentId) {
+    return await this.list({ where: { parentId } });
+  }
+  /**
+   * Get full event tree (hierarchy)
+   *
+   * @param eventId - Root event ID
+   * @returns Object with root event and nested children
+   */
+  async getEventTree(eventId) {
+    const event = await this.get({ id: eventId });
+    if (!event) return null;
+    return await event.getHierarchy().then((h) => h.current);
+  }
+  async getAssets(eventId, relationship) {
+    return getOwnedAssetsFromCollection(this, eventId, relationship);
+  }
+  async addAsset(eventId, asset, relationship = "attachment", sortOrder = 0) {
+    await addOwnedAssetFromCollection(
+      this,
+      "Event",
+      eventId,
+      asset,
+      relationship,
+      sortOrder
+    );
+  }
+  async removeAsset(eventId, assetId, relationship) {
+    await removeOwnedAssetFromCollection(
+      this,
+      "Event",
+      eventId,
+      assetId,
+      relationship
+    );
+  }
+  /**
+   * Search events with filters
+   *
+   * @param query - Search query for name/description
+   * @param filters - Additional filter criteria
+   * @returns Array of matching Event instances
+   */
+  async search(query, filters) {
+    let events = await this.list({});
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      events = events.filter(
+        (e) => e.name?.toLowerCase().includes(lowerQuery) || e.description?.toLowerCase().includes(lowerQuery)
+      );
+    }
+    if (filters) {
+      if (filters.typeId) {
+        events = events.filter((e) => e.typeId === filters.typeId);
+      }
+      if (filters.seriesId) {
+        events = events.filter((e) => e.seriesId === filters.seriesId);
+      }
+      if (filters.placeId) {
+        events = events.filter((e) => e.placeId === filters.placeId);
+      }
+      if (filters.status) {
+        if (Array.isArray(filters.status)) {
+          events = events.filter((e) => filters.status?.includes(e.status));
+        } else {
+          events = events.filter((e) => e.status === filters.status);
+        }
+      }
+      if (filters.startDate) {
+        const startDate = filters.startDate;
+        events = events.filter((e) => e.startDate && e.startDate >= startDate);
+      }
+      if (filters.endDate) {
+        const endDate = filters.endDate;
+        events = events.filter((e) => e.startDate && e.startDate <= endDate);
+      }
+      if (filters.organizerId) {
+        events = events.filter(async (e) => {
+          const series = await e.getSeries();
+          return series && series.organizerId === filters.organizerId;
+        });
+      }
+    }
+    return events;
+  }
+  /**
+   * Get events in progress
+   *
+   * @returns Array of Event instances currently in progress
+   */
+  async getInProgress() {
+    const inProgressEvents = await this.getByStatus("in_progress");
+    return inProgressEvents.filter((event) => event.isInProgress());
+  }
+  // ============================================
+  // Tenant Helper Methods
+  // ============================================
+  /**
+   * Find all events for a specific tenant
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of Event instances for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global events (no tenant association)
+   *
+   * @returns Array of Event instances with no tenant
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find events for a tenant including global events
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of Event instances for the tenant and global events
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const EventCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EventCollection
+}, Symbol.toStringTag, { value: "Module" }));
+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;
+};
+let EventParticipant = class extends SmrtObject {
+  tenantId = null;
+  eventId = "";
+  profileId = "";
+  // FK to Profile (from @happyvertical/smrt-profiles)
+  role = "";
+  // Participant role (ParticipantRole or custom)
+  placement = null;
+  // Numeric position/placement
+  groupId = "";
+  // Optional grouping (e.g., team ID for individual players)
+  metadata = "";
+  // JSON metadata (stored as text)
+  externalId = "";
+  // External system identifier
+  source = "";
+  // Source system
+  // Timestamps
+  createdAt = /* @__PURE__ */ new Date();
+  updatedAt = /* @__PURE__ */ new Date();
+  constructor(options = {}) {
+    super(options);
+    if (options.eventId) this.eventId = options.eventId;
+    if (options.profileId) this.profileId = options.profileId;
+    if (options.role !== void 0) this.role = options.role;
+    if (options.placement !== void 0) this.placement = options.placement;
+    if (options.groupId !== void 0) this.groupId = options.groupId;
+    if (options.externalId !== void 0) this.externalId = options.externalId;
+    if (options.source !== void 0) this.source = options.source;
+    if (options.metadata !== void 0) {
+      if (typeof options.metadata === "string") {
+        this.metadata = options.metadata;
+      } else {
+        this.metadata = JSON.stringify(options.metadata);
+      }
+    }
+    if (options.createdAt) this.createdAt = options.createdAt;
+    if (options.updatedAt) this.updatedAt = options.updatedAt;
+  }
+  /**
+   * Get metadata as parsed object
+   *
+   * @returns Parsed metadata object or empty object
+   */
+  getMetadata() {
+    if (!this.metadata) return {};
+    try {
+      return JSON.parse(this.metadata);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set metadata from object
+   *
+   * @param data - Metadata object to store
+   */
+  setMetadata(data) {
+    this.metadata = JSON.stringify(data);
+  }
+  /**
+   * Update metadata by merging with existing values
+   *
+   * @param updates - Partial metadata to merge
+   */
+  updateMetadata(updates) {
+    const current = this.getMetadata();
+    this.setMetadata({ ...current, ...updates });
+  }
+  /**
+   * Get the event for this participant
+   *
+   * @returns Event instance or null
+   */
+  async getEvent() {
+    if (!this.eventId) return null;
+    const { EventCollection: EventCollection2 } = await Promise.resolve().then(() => EventCollection$1);
+    const collection = await EventCollection2.create(this.options);
+    return await collection.get({ id: this.eventId });
+  }
+  /**
+   * Get the profile for this participant
+   *
+   * @returns Profile instance or null
+   */
+  async getProfile() {
+    if (!this.profileId) return null;
+    try {
+      const { ProfileCollection } = await import("@happyvertical/smrt-profiles");
+      const collection = await ProfileCollection.create(this.options);
+      return await collection.get({ id: this.profileId });
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get group participants (others with same groupId)
+   *
+   * @returns Array of EventParticipant instances
+   */
+  async getGroupParticipants() {
+    if (!this.groupId) return [];
+    const { EventParticipantCollection: EventParticipantCollection2 } = await Promise.resolve().then(() => EventParticipantCollection$1);
+    const collection = await EventParticipantCollection2.create(
+      this.options
+    );
+    const participants = await collection.list({
+      where: { eventId: this.eventId, groupId: this.groupId }
+    });
+    return participants.filter((p) => p.id !== this.id);
+  }
+  /**
+   * Check if this is a home participant (placement = 0)
+   *
+   * @returns True if placement is 0
+   */
+  isHome() {
+    return this.placement === 0;
+  }
+  /**
+   * Check if this is an away participant (placement = 1)
+   *
+   * @returns True if placement is 1
+   */
+  isAway() {
+    return this.placement === 1;
+  }
+};
+__decorateClass$3([
+  tenantId({ nullable: true })
+], EventParticipant.prototype, "tenantId", 2);
+__decorateClass$3([
+  foreignKey("Event")
+], EventParticipant.prototype, "eventId", 2);
+__decorateClass$3([
+  crossPackageRef("@happyvertical/smrt-profiles:Profile")
+], EventParticipant.prototype, "profileId", 2);
+EventParticipant = __decorateClass$3([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    // Junction table - uses event_id + profile_id + role as natural key
+    // instead of slug-based conflict columns
+    conflictColumns: ["event_id", "profile_id", "role"],
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get", "create", "update"] },
+    cli: true
+  })
+], EventParticipant);
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 = decorator(result) || result;
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "", value);
+let EventParticipantCollection = class extends SmrtJunction {
+  leftField = "eventId";
+  rightField = "profileId";
+  // EventParticipant has no sortOrder column; `placement` is domain ordering
+  // (0=home, 1=away) and must not be auto-assigned by setLinks.
+  sortField = null;
+  positionField = null;
+  // ============================================
+  // Domain helpers
+  // ============================================
+  /**
+   * Get participants ordered by placement (nulls last).
+   */
+  async getByPlacement(eventId) {
+    const participants = await this.byLeft(eventId);
+    return participants.sort((a, b) => {
+      if (a.placement === null && b.placement === null) return 0;
+      if (a.placement === null) return 1;
+      if (b.placement === null) return -1;
+      return a.placement - b.placement;
+    });
+  }
+  /**
+   * Get participants by group within an event.
+   */
+  async getByGroup(eventId, groupId) {
+    return this.byLeft(eventId, { groupId });
+  }
+  /**
+   * Get the home participant(s) — placement = 0.
+   */
+  async getHome(eventId) {
+    return this.byLeft(eventId, { placement: 0 });
+  }
+  /**
+   * Get the away participant(s) — placement = 1.
+   */
+  async getAway(eventId) {
+    return this.byLeft(eventId, { placement: 1 });
+  }
+  /**
+   * Search participants with optional filters.
+   */
+  async search(filters) {
+    let participants = await this.list({});
+    if (filters.eventId) {
+      participants = participants.filter((p) => p.eventId === filters.eventId);
+    }
+    if (filters.profileId) {
+      participants = participants.filter(
+        (p) => p.profileId === filters.profileId
+      );
+    }
+    if (filters.role) {
+      participants = participants.filter((p) => p.role === filters.role);
+    }
+    if (filters.groupId) {
+      participants = participants.filter((p) => p.groupId === filters.groupId);
+    }
+    return participants;
+  }
+  /**
+   * Get participation statistics for a profile, optionally filtered by event type.
+   */
+  async getParticipantStats(profileId, eventTypeId) {
+    const participants = await this.byRight(profileId);
+    let filteredParticipants = participants;
+    if (eventTypeId) {
+      filteredParticipants = [];
+      for (const participant of participants) {
+        const event = await participant.getEvent();
+        if (event && event.typeId === eventTypeId) {
+          filteredParticipants.push(participant);
+        }
+      }
+    }
+    const byRole = {};
+    const byPlacement = {};
+    for (const participant of filteredParticipants) {
+      byRole[participant.role] = (byRole[participant.role] || 0) + 1;
+      if (participant.placement !== null) {
+        byPlacement[participant.placement] = (byPlacement[participant.placement] || 0) + 1;
+      }
+    }
+    return {
+      totalEvents: filteredParticipants.length,
+      byRole,
+      byPlacement
+    };
+  }
+  // ============================================
+  // Tenant helpers
+  // ============================================
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+};
+__publicField(EventParticipantCollection, "_itemClass", EventParticipant);
+EventParticipantCollection = __decorateClass$2([
+  smrt()
+], EventParticipantCollection);
+const EventParticipantCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get EventParticipantCollection() {
+    return EventParticipantCollection;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+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 EventSeries = class extends SmrtObject {
+  tenantId = null;
+  name = "";
+  typeId = "";
+  organizerId = "";
+  // FK to Profile (from @happyvertical/smrt-profiles)
+  description = "";
+  startDate = null;
+  endDate = null;
+  recurrence = "";
+  // JSON recurrence pattern (stored as text)
+  metadata = "";
+  // JSON metadata (stored as text)
+  externalId = "";
+  // External system identifier
+  source = "";
+  // Source system (e.g., 'ticketmaster', 'espn')
+  // Timestamps
+  createdAt = /* @__PURE__ */ new Date();
+  updatedAt = /* @__PURE__ */ new Date();
+  constructor(options = {}) {
+    super(options);
+    if (options.typeId) this.typeId = options.typeId;
+    if (options.organizerId) this.organizerId = options.organizerId;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.startDate !== void 0)
+      this.startDate = options.startDate || null;
+    if (options.endDate !== void 0) this.endDate = options.endDate || null;
+    if (options.externalId !== void 0) this.externalId = options.externalId;
+    if (options.source !== void 0) this.source = options.source;
+    if (options.recurrence !== void 0) {
+      if (typeof options.recurrence === "string") {
+        this.recurrence = options.recurrence;
+      } else {
+        this.recurrence = JSON.stringify(options.recurrence);
+      }
+    }
+    if (options.metadata !== void 0) {
+      if (typeof options.metadata === "string") {
+        this.metadata = options.metadata;
+      } else {
+        this.metadata = JSON.stringify(options.metadata);
+      }
+    }
+    if (options.createdAt) this.createdAt = options.createdAt;
+    if (options.updatedAt) this.updatedAt = options.updatedAt;
+  }
+  /**
+   * Get recurrence pattern as parsed object
+   *
+   * @returns Parsed recurrence pattern or null
+   */
+  getRecurrence() {
+    if (!this.recurrence) return null;
+    try {
+      return JSON.parse(this.recurrence);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Set recurrence pattern from object
+   *
+   * @param pattern - Recurrence pattern to store
+   */
+  setRecurrence(pattern) {
+    this.recurrence = JSON.stringify(pattern);
+  }
+  /**
+   * Get metadata as parsed object
+   *
+   * @returns Parsed metadata object or empty object
+   */
+  getMetadata() {
+    if (!this.metadata) return {};
+    try {
+      return JSON.parse(this.metadata);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set metadata from object
+   *
+   * @param data - Metadata object to store
+   */
+  setMetadata(data) {
+    this.metadata = JSON.stringify(data);
+  }
+  /**
+   * Update metadata by merging with existing values
+   *
+   * @param updates - Partial metadata to merge
+   */
+  updateMetadata(updates) {
+    const current = this.getMetadata();
+    this.setMetadata({ ...current, ...updates });
+  }
+  /**
+   * Get the event type for this series
+   *
+   * @returns EventType instance or null
+   */
+  async getType() {
+    if (!this.typeId) return null;
+    const { EventTypeCollection: EventTypeCollection2 } = await Promise.resolve().then(() => EventTypeCollection$1);
+    const collection = await EventTypeCollection2.create(this.options);
+    return await collection.get({ id: this.typeId });
+  }
+  /**
+   * Get the organizer profile for this series
+   *
+   * @returns Profile instance or null
+   */
+  async getOrganizer() {
+    if (!this.organizerId) return null;
+    try {
+      const { ProfileCollection } = await import("@happyvertical/smrt-profiles");
+      const collection = await ProfileCollection.create(this.options);
+      return await collection.get({ id: this.organizerId });
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get all events in this series
+   *
+   * @returns Array of Event instances
+   */
+  async getEvents() {
+    const { EventCollection: EventCollection2 } = await Promise.resolve().then(() => EventCollection$1);
+    const collection = await EventCollection2.create(this.options);
+    return await collection.list({ where: { seriesId: this.id } });
+  }
+  /**
+   * Check if series is currently active
+   *
+   * @returns True if current date is between start and end
+   */
+  isActive() {
+    const now = /* @__PURE__ */ new Date();
+    if (this.startDate && now < this.startDate) return false;
+    if (this.endDate && now > this.endDate) return false;
+    return true;
+  }
+};
+__decorateClass$1([
+  tenantId({ nullable: true })
+], EventSeries.prototype, "tenantId", 2);
+__decorateClass$1([
+  foreignKey("EventType")
+], EventSeries.prototype, "typeId", 2);
+__decorateClass$1([
+  crossPackageRef("@happyvertical/smrt-profiles:Profile")
+], EventSeries.prototype, "organizerId", 2);
+EventSeries = __decorateClass$1([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get", "create", "update"] },
+    cli: true
+  })
+], EventSeries);
+class EventSeriesCollection extends SmrtCollection {
+  static _itemClass = EventSeries;
+  /**
+   * Get series by organizer
+   *
+   * @param organizerId - Profile ID of the organizer
+   * @returns Array of EventSeries instances
+   */
+  async getByOrganizer(organizerId) {
+    return await this.list({ where: { organizerId } });
+  }
+  /**
+   * Get currently active series
+   *
+   * @returns Array of EventSeries instances active today
+   */
+  async getActive() {
+    const allSeries = await this.list({});
+    const now = /* @__PURE__ */ new Date();
+    return allSeries.filter((series) => {
+      if (series.startDate && now < series.startDate) return false;
+      if (series.endDate && now > series.endDate) return false;
+      return true;
+    });
+  }
+  /**
+   * Get upcoming series
+   *
+   * @param limit - Maximum number of series to return
+   * @returns Array of EventSeries instances starting in the future
+   */
+  async getUpcoming(limit) {
+    const allSeries = await this.list({});
+    const now = /* @__PURE__ */ new Date();
+    const upcoming = allSeries.filter((series) => series.startDate && series.startDate > now).sort((a, b) => {
+      if (!a.startDate || !b.startDate) return 0;
+      return a.startDate.getTime() - b.startDate.getTime();
+    });
+    return limit ? upcoming.slice(0, limit) : upcoming;
+  }
+  /**
+   * Get series by type
+   *
+   * @param typeId - EventType ID
+   * @returns Array of EventSeries instances
+   */
+  async getByType(typeId) {
+    return await this.list({ where: { typeId } });
+  }
+  /**
+   * Search series with filters
+   *
+   * @param query - Search query for name/description
+   * @param filters - Additional filter criteria
+   * @returns Array of matching EventSeries instances
+   */
+  async search(query, filters) {
+    let series = await this.list({});
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      series = series.filter(
+        (s) => s.name?.toLowerCase().includes(lowerQuery) || s.description?.toLowerCase().includes(lowerQuery)
+      );
+    }
+    if (filters) {
+      if (filters.typeId) {
+        series = series.filter((s) => s.typeId === filters.typeId);
+      }
+      if (filters.organizerId) {
+        series = series.filter((s) => s.organizerId === filters.organizerId);
+      }
+      if (filters.startDate) {
+        const startDate = filters.startDate;
+        series = series.filter((s) => s.startDate && s.startDate >= startDate);
+      }
+      if (filters.endDate) {
+        const endDate = filters.endDate;
+        series = series.filter((s) => s.endDate && s.endDate <= endDate);
+      }
+    }
+    return series;
+  }
+  // ============================================
+  // Tenant Helper Methods
+  // ============================================
+  /**
+   * Find all event series for a specific tenant
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of EventSeries instances for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global event series (no tenant association)
+   *
+   * @returns Array of EventSeries instances with no tenant
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find event series for a tenant including global series
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of EventSeries instances for the tenant and global series
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const EventSeriesCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EventSeriesCollection
+}, 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 EventType = class extends SmrtObject {
+  tenantId = null;
+  name = "";
+  description = "";
+  // Optional description
+  schema = "";
+  // JSON schema for event metadata (stored as text)
+  participantSchema = "";
+  // JSON schema for participant metadata (stored as text)
+  // Timestamps
+  createdAt = /* @__PURE__ */ new Date();
+  updatedAt = /* @__PURE__ */ new Date();
+  constructor(options = {}) {
+    super(options);
+    if (options.name) this.name = options.name;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.schema !== void 0) {
+      if (typeof options.schema === "string") {
+        this.schema = options.schema;
+      } else {
+        this.schema = JSON.stringify(options.schema);
+      }
+    }
+    if (options.participantSchema !== void 0) {
+      if (typeof options.participantSchema === "string") {
+        this.participantSchema = options.participantSchema;
+      } else {
+        this.participantSchema = JSON.stringify(options.participantSchema);
+      }
+    }
+    if (options.createdAt) this.createdAt = options.createdAt;
+    if (options.updatedAt) this.updatedAt = options.updatedAt;
+  }
+  /**
+   * Get schema as parsed object
+   *
+   * @returns Parsed schema object or empty object if no schema
+   */
+  getSchema() {
+    if (!this.schema) return {};
+    try {
+      return JSON.parse(this.schema);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set schema from object
+   *
+   * @param data - Schema object to store
+   */
+  setSchema(data) {
+    this.schema = JSON.stringify(data);
+  }
+  /**
+   * Get participant schema as parsed object
+   *
+   * @returns Parsed participant schema object or empty object
+   */
+  getParticipantSchema() {
+    if (!this.participantSchema) return {};
+    try {
+      return JSON.parse(this.participantSchema);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Set participant schema from object
+   *
+   * @param data - Participant schema object to store
+   */
+  setParticipantSchema(data) {
+    this.participantSchema = JSON.stringify(data);
+  }
+  /**
+   * Convenience method for slug-based lookup
+   *
+   * @param slug - The slug to search for
+   * @returns EventType instance or null if not found
+   */
+  static async getBySlug(_slug) {
+    return null;
+  }
+};
+__decorateClass([
+  tenantId({ nullable: true })
+], EventType.prototype, "tenantId", 2);
+__decorateClass([
+  field({ required: true })
+], EventType.prototype, "name", 2);
+EventType = __decorateClass([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get", "create"] },
+    cli: true
+  })
+], EventType);
+class EventTypeCollection extends SmrtCollection {
+  static _itemClass = EventType;
+  /**
+   * Get or create an event type by slug
+   *
+   * @param slug - EventType slug (e.g., 'basketball-game', 'concert')
+   * @param name - Optional display name (defaults to capitalized slug)
+   * @returns EventType instance
+   */
+  async getOrCreate(slug, name) {
+    const existing = await this.get({ slug });
+    if (existing) {
+      return existing;
+    }
+    const displayName = name || slug.replace(/-/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
+    return await this.create({
+      slug,
+      name: displayName
+    });
+  }
+  /**
+   * Get an event type by slug
+   *
+   * @param slug - EventType slug to search for
+   * @returns EventType instance or null if not found
+   */
+  async getBySlug(slug) {
+    return await this.get({ slug });
+  }
+  /**
+   * Initialize default event types
+   *
+   * Creates common event types if they don't exist:
+   * - Sports: game, period, goal, assist, penalty
+   * - Entertainment: concert, performance, song
+   * - Professional: conference, session, presentation, workshop
+   * - Community: meeting, agenda-item, motion, vote
+   *
+   * @returns Array of created/existing event types
+   */
+  async initializeDefaults() {
+    const defaults = [
+      // Sports
+      { slug: "game", name: "Game" },
+      { slug: "match", name: "Match" },
+      { slug: "period", name: "Period" },
+      { slug: "quarter", name: "Quarter" },
+      { slug: "inning", name: "Inning" },
+      { slug: "goal", name: "Goal" },
+      { slug: "assist", name: "Assist" },
+      { slug: "penalty", name: "Penalty" },
+      { slug: "substitution", name: "Substitution" },
+      // Entertainment
+      { slug: "concert", name: "Concert" },
+      { slug: "performance", name: "Performance" },
+      { slug: "set", name: "Set" },
+      { slug: "song", name: "Song" },
+      { slug: "theater", name: "Theater" },
+      { slug: "show", name: "Show" },
+      // Professional
+      { slug: "conference", name: "Conference" },
+      { slug: "session", name: "Session" },
+      { slug: "presentation", name: "Presentation" },
+      { slug: "workshop", name: "Workshop" },
+      { slug: "seminar", name: "Seminar" },
+      { slug: "keynote", name: "Keynote" },
+      { slug: "panel", name: "Panel" },
+      // Community
+      { slug: "meeting", name: "Meeting" },
+      { slug: "town-hall", name: "Town Hall" },
+      { slug: "agenda-item", name: "Agenda Item" },
+      { slug: "motion", name: "Motion" },
+      { slug: "amendment", name: "Amendment" },
+      { slug: "vote", name: "Vote" },
+      { slug: "discussion", name: "Discussion" },
+      // General
+      { slug: "event", name: "Event" },
+      { slug: "activity", name: "Activity" },
+      { slug: "action", name: "Action" }
+    ];
+    const types = [];
+    for (const def of defaults) {
+      const type = await this.getOrCreate(def.slug, def.name);
+      types.push(type);
+    }
+    return types;
+  }
+  // ============================================
+  // Tenant Helper Methods
+  // ============================================
+  /**
+   * Find all event types for a specific tenant
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of EventType instances for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find all global event types (no tenant association)
+   *
+   * @returns Array of EventType instances with no tenant
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find event types for a tenant including global types
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of EventType instances for the tenant and global types
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const EventTypeCollection$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EventTypeCollection
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  EVENTS_MODULE_META,
+  EVENTS_UI_SLOTS,
+  Event,
+  EventAsset,
+  EventAssetCollection,
+  EventCollection,
+  EventParticipant,
+  EventParticipantCollection,
+  EventSeries,
+  EventSeriesCollection,
+  EventType,
+  EventTypeCollection,
+  calculateDuration,
+  calculateNextOccurrence,
+  checkSchedulingConflict,
+  formatDuration,
+  formatEventDateRange,
+  generateEventSlug,
+  getEventStatusFromDates,
+  isEventNow,
+  parseRecurrencePattern,
+  sortEventsByDate,
+  validateEventStatus
+};
+//# sourceMappingURL=index.js.map