@open-mercato/core 0.7.0 → 0.7.1-develop.7102.1.b41f7e3e51

package/src/modules/customers/commands/deals.ts

@@ -45,6 +45,13 @@ import type { CrudIndexerConfig, CrudEventsConfig } from '@open-mercato/shared/l
 import { E } from '#generated/entities.ids.generated'
 import { findWithDecryption, findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { isMissingDealStageTransitionTable, warnMissingDealStageTransitionTable } from '../lib/dealStageTransitionTable'
+import {
+  dealClosureOutcomeFromStatus,
+  loadClosurePipelineStageSnapshot,
+  type DealClosureOutcome,
+  type PipelineStageSnapshot,
+} from '../lib/closureStage'
+import { canonicalDealStatus, isClosedDealStatus } from '../lib/dealStatus'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
 const logger = createLogger('customers')
@@ -65,20 +72,6 @@ const dealCrudEvents: CrudEventsConfig = {
   }),
 }
 
-type PipelineStageSnapshot = {
-  id: string
-  pipelineId: string
-  label: string
-  order: number
-}
-
-type DealClosureOutcome = 'won' | 'lost'
-
-const TERMINAL_PIPELINE_STAGE_LABELS: Record<DealClosureOutcome, ReadonlySet<string>> = {
-  won: new Set(['won', 'win', 'closed won', 'closed win']),
-  lost: new Set(['lost', 'loose', 'closed lost', 'closed loose']),
-}
-
 type DealStageTransitionSnapshot = {
   id: string
   pipelineId: string
@@ -123,54 +116,14 @@ async function loadPipelineStageSnapshot(
   }
 }
 
-function normalizePipelineStageLabel(value: string): string {
-  return value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, ' ')
-    .trim()
-}
-
 function resolveRequestedClosureOutcome(input: DealUpdateInput): DealClosureOutcome | null {
   if (input.closureOutcome === 'won' || input.closureOutcome === 'lost') {
     return input.closureOutcome
   }
-  if (input.status === 'win') return 'won'
-  if (input.status === 'loose') return 'lost'
-  return null
-}
-
-async function loadClosurePipelineStageSnapshot(
-  em: EntityManager,
-  input: {
-    pipelineId: string | null
-    closureOutcome: DealClosureOutcome
-    tenantId: string
-    organizationId: string
-  },
-): Promise<PipelineStageSnapshot | null> {
-  if (!input.pipelineId) return null
-
-  const stages = await findWithDecryption(
-    em,
-    CustomerPipelineStage,
-    {
-      pipelineId: input.pipelineId,
-      tenantId: input.tenantId,
-      organizationId: input.organizationId,
-    },
-    { orderBy: { order: 'ASC' } },
-    { tenantId: input.tenantId, organizationId: input.organizationId },
-  )
-  const aliases = TERMINAL_PIPELINE_STAGE_LABELS[input.closureOutcome]
-  const stage = stages.find((candidate) => aliases.has(normalizePipelineStageLabel(candidate.label)))
-  if (!stage) return null
-  return {
-    id: stage.id,
-    pipelineId: stage.pipelineId,
-    label: stage.label,
-    order: stage.order,
-  }
+  // `win` / `loose` are what the UI closure flows persist; `won` / `lost` are the
+  // spellings the AI stage tool persists. Both must derive the same closure outcome so
+  // every closed deal lands in the pipeline's terminal stage (#5107).
+  return dealClosureOutcomeFromStatus(input.status)
 }
 
 async function resolvePipelineStageValue(
@@ -739,6 +692,7 @@ const updateDealCommand: CommandHandler<DealUpdateInput, { dealId: string }> = {
     let nextPipelineStageLabel: string | null = null
     let resolvedCurrentPipelineStageLabel: string | null = null
     let pipelineStageAssignmentChanged = false
+    let requestedClosureOutcome: DealClosureOutcome | null = null
 
     await runCrudCommandWrite({
       ctx,
@@ -759,7 +713,7 @@ const updateDealCommand: CommandHandler<DealUpdateInput, { dealId: string }> = {
       }),
       phases: [
         async () => {
-          const requestedClosureOutcome = resolveRequestedClosureOutcome(parsed)
+          requestedClosureOutcome = resolveRequestedClosureOutcome(parsed)
           const requestedPipelineId =
             parsed.pipelineId !== undefined ? parsed.pipelineId ?? null : record.pipelineId ?? null
           const closureStageSnapshot =
@@ -828,6 +782,27 @@ const updateDealCommand: CommandHandler<DealUpdateInput, { dealId: string }> = {
           if (parsed.ownerUserId !== undefined) record.ownerUserId = parsed.ownerUserId ?? null
           if (parsed.source !== undefined) record.source = parsed.source ?? null
           if (parsed.closureOutcome !== undefined) record.closureOutcome = parsed.closureOutcome ?? null
+          // Derive the outcome only when the status spelling alone drives the closure —
+          // the same condition that triggers the terminal-stage move below — so an
+          // explicit non-terminal pipelineStageId never produces a half-closed state.
+          else if (requestedClosureOutcome && parsed.pipelineStageId === undefined) {
+            record.closureOutcome = requestedClosureOutcome
+          } else if (
+            parsed.status !== undefined &&
+            !requestedClosureOutcome &&
+            // `closed` is a seeded dictionary status: saving it is not a reopen, so only
+            // a genuinely non-closed status clears stored closure state — and only when
+            // the deal actually carries any (a no-op status echo must not wipe loss data).
+            // Canonicalize first: `dealClosureOutcomeFromStatus` above already matches
+            // case-insensitively, so matching `closed` exactly would let `Closed` through
+            // this guard and null the operator's loss notes.
+            !isClosedDealStatus(canonicalDealStatus(parsed.status)) &&
+            record.closureOutcome !== null
+          ) {
+            record.closureOutcome = null
+            if (parsed.lossReasonId === undefined) record.lossReasonId = null
+            if (parsed.lossNotes === undefined) record.lossNotes = null
+          }
           if (parsed.lossReasonId !== undefined) record.lossReasonId = parsed.lossReasonId ?? null
           if (parsed.lossNotes !== undefined) record.lossNotes = parsed.lossNotes ?? null
         },

package/src/modules/customers/commands/interactions.ts

@@ -114,7 +114,7 @@ type InteractionSnapshot = {
     allDay: boolean | null
     recurrenceRule: string | null
     recurrenceEnd: Date | null
-    participants: Array<{ userId: string; name?: string; email?: string; status?: string }> | null
+    participants: Array<{ userId?: string; name?: string; email?: string; status?: string }> | null
     reminderMinutes: number | null
     visibility: string | null
     linkedEntities: Array<{ id: string; type: string; label: string }> | null

package/src/modules/customers/commands/personCompanyLinks.ts

@@ -1,5 +1,5 @@
 import { registerCommand } from '@open-mercato/shared/lib/commands'
-import type { CommandHandler } from '@open-mercato/shared/lib/commands'
+import type { CommandHandler, CommandRuntimeContext } from '@open-mercato/shared/lib/commands'
 import type { CrudEventsConfig } from '@open-mercato/shared/lib/crud/types'
 import { emitCrudSideEffects, emitCrudUndoSideEffects } from '@open-mercato/shared/lib/commands/helpers'
 import { CrudHttpError, notFound } from '@open-mercato/shared/lib/crud/errors'
@@ -24,14 +24,27 @@ import {
   findDeletedPersonCompanyLink,
   loadPersonCompanyLinks,
   promoteFallbackPrimaryLink,
+  removePersonCompanyLink,
 } from '../lib/personCompanies'
 import {
+  emitQueryIndexUpsertEvents,
   ensureOrganizationScope,
   ensureTenantScope,
   extractUndoPayload,
+  type QueryIndexEventEntry,
 } from './shared'
+import type { CustomersEventId } from '../events'
+import { E } from '#generated/entities.ids.generated'
+import type { EventBus } from '@open-mercato/events'
 import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 import { resolveRedoSnapshot } from '@open-mercato/shared/lib/commands/redo'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('customers').child({ component: 'personCompanyLinks' })
+
+// Typed against the module's declared event ids so removing or renaming the declaration in
+// `events.ts` fails the build here rather than emitting an undeclared event at runtime.
+const PROFILE_ONLY_DETACHED_EVENT: CustomersEventId = 'customers.person.company_assignment.detached'
 
 type PersonCompanyLinkSnapshot = {
   id: string
@@ -48,6 +61,65 @@ type PersonCompanyLinkUndoPayload = {
   after?: PersonCompanyLinkSnapshot | null
 }
 
+/**
+ * Snapshot of a legacy profile-only company assignment — `customer_person_profiles.company_id`
+ * set with no backing link row (#5114). It carries no link id because none exists; `kind`
+ * discriminates it from `PersonCompanyLinkSnapshot` in the delete command's undo payload.
+ */
+type PersonCompanyProfileAssignmentSnapshot = {
+  kind: 'profile-only'
+  personEntityId: string
+  companyEntityId: string
+  tenantId: string
+  organizationId: string
+}
+
+type PersonCompanyLinkDeleteSnapshot = PersonCompanyLinkSnapshot | PersonCompanyProfileAssignmentSnapshot
+
+type PersonCompanyLinkDeleteUndoPayload = {
+  before?: PersonCompanyLinkDeleteSnapshot | null
+}
+
+type PersonCompanyLinkDeleteResult = {
+  linkId: string | null
+  personEntityId: string | null
+  companyEntityId: string | null
+}
+
+function isProfileAssignmentSnapshot(
+  snapshot: PersonCompanyLinkDeleteSnapshot | null | undefined,
+): snapshot is PersonCompanyProfileAssignmentSnapshot {
+  return Boolean(snapshot) && (snapshot as PersonCompanyProfileAssignmentSnapshot).kind === 'profile-only'
+}
+
+function resolveProfileOnlyTarget(
+  parsed: PersonCompanyLinkDeleteInput,
+): { personEntityId: string; companyEntityId: string } | null {
+  if (parsed.linkId) return null
+  if (!parsed.personEntityId || !parsed.companyEntityId) return null
+  return { personEntityId: parsed.personEntityId, companyEntityId: parsed.companyEntityId }
+}
+
+function personQueryIndexEntries(
+  person: CustomerEntity,
+  profile: CustomerPersonProfile,
+): QueryIndexEventEntry[] {
+  return [
+    {
+      entityType: E.customers.customer_entity,
+      recordId: person.id,
+      tenantId: person.tenantId,
+      organizationId: person.organizationId,
+    },
+    {
+      entityType: E.customers.customer_person_profile,
+      recordId: profile.id,
+      tenantId: profile.tenantId,
+      organizationId: profile.organizationId,
+    },
+  ]
+}
+
 const personCompanyLinkCrudEvents: CrudEventsConfig = {
   module: 'customers',
   entity: 'person_company_link',
@@ -576,12 +648,144 @@ const updatePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkUpdateInpu
   },
 }
 
-const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInput, { linkId: string }> = {
+/**
+ * Detach a legacy profile-only company assignment: `customer_person_profiles.company_id`
+ * points at the company but no `customer_person_company_links` row was ever created, so
+ * there is no link row for the id-based branch to soft-delete (#5114). Running it as part
+ * of the same command keeps the audit entry, the undo token and the CRUD cache
+ * invalidation identical to a link-backed detach.
+ */
+async function detachProfileOnlyCompany(
+  em: EntityManager,
+  ctx: CommandRuntimeContext,
+  parsed: PersonCompanyLinkDeleteInput,
+  target: { personEntityId: string; companyEntityId: string },
+): Promise<PersonCompanyLinkDeleteResult> {
+  const person = await requirePersonEntity(em, target.personEntityId, parsed.tenantId, parsed.organizationId)
+  const profile = await requirePersonProfile(em, person)
+  const assignedCompany = profile.company
+  const assignedCompanyId = typeof assignedCompany === 'string' ? assignedCompany : assignedCompany?.id ?? null
+  if (assignedCompanyId !== target.companyEntityId) {
+    throw notFound('Company link not found')
+  }
+
+  await withAtomicFlush(em, [
+    () => removePersonCompanyLink(em, person, profile, target.companyEntityId),
+  ], { transaction: true })
+
+  // There is no link entity to hand to `emitCrudSideEffects`; what changed is the
+  // person's own company assignment, so reindex the person and its profile instead.
+  await emitQueryIndexUpsertEvents(ctx, personQueryIndexEntries(person, profile))
+  await emitProfileOnlyDetachedEvent(ctx, person, target.companyEntityId)
+
+  return { linkId: null, personEntityId: person.id, companyEntityId: target.companyEntityId }
+}
+
+/**
+ * Live-refresh signal for the company People tab and the person Companies tab, which the
+ * link-backed branch gets from `customers.person_company_link.deleted` via `emitCrudSideEffects`.
+ * The profile-only branch has no link row to emit that for, so it publishes the sibling
+ * `clientBroadcast` event instead (#5114). `tenantId` must travel in the payload: the event bus
+ * only forwards a broadcast event cross-process when the payload carries a tenant scope. The
+ * write is already committed, so a failed refresh signal must never fail the detach.
+ */
+async function emitProfileOnlyDetachedEvent(
+  ctx: CommandRuntimeContext,
+  person: CustomerEntity,
+  companyEntityId: string,
+): Promise<void> {
+  try {
+    const bus = ctx.container.resolve<EventBus>('eventBus')
+    await bus.emitEvent(
+      PROFILE_ONLY_DETACHED_EVENT,
+      {
+        linkId: null,
+        personEntityId: person.id,
+        companyEntityId,
+        tenantId: person.tenantId,
+        organizationId: person.organizationId,
+      },
+      { tenantId: person.tenantId, organizationId: person.organizationId },
+    )
+  } catch (err) {
+    logger.warn('Profile-only company detach broadcast failed', {
+      command: 'customers.personCompanyLinks.delete',
+      personEntityId: person.id,
+      companyEntityId,
+      err,
+    })
+  }
+}
+
+/**
+ * Undo counterpart of `detachProfileOnlyCompany`: re-point the person's legacy
+ * `profile.company` at the company it was detached from. The lookups run in the first
+ * flush phase and the assignment in the second so the encryption subscriber's
+ * re-baseline on find cannot drop the pending change (#2507).
+ */
+async function restoreProfileOnlyCompany(
+  ctx: CommandRuntimeContext,
+  before: PersonCompanyProfileAssignmentSnapshot,
+): Promise<void> {
+  const em = (ctx.container.resolve('em') as EntityManager).fork()
+  let person: CustomerEntity | null = null
+  let profile: CustomerPersonProfile | null = null
+  let company: CustomerEntity | null = null
+
+  await withAtomicFlush(em, [
+    async () => {
+      person = await findOneWithDecryption(
+        em,
+        CustomerEntity,
+        { id: before.personEntityId, kind: 'person', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
+        undefined,
+        { tenantId: before.tenantId, organizationId: before.organizationId },
+      )
+      if (!person) return
+      profile = await findOneWithDecryption(
+        em,
+        CustomerPersonProfile,
+        { entity: person },
+        { populate: ['company'] },
+        { tenantId: before.tenantId, organizationId: before.organizationId },
+      )
+      if (!profile) return
+      company = await findOneWithDecryption(
+        em,
+        CustomerEntity,
+        { id: before.companyEntityId, kind: 'company', tenantId: before.tenantId, organizationId: before.organizationId, deletedAt: null },
+        undefined,
+        { tenantId: before.tenantId, organizationId: before.organizationId },
+      )
+    },
+    () => {
+      if (profile && company) profile.company = company
+    },
+  ], { transaction: true })
+
+  if (person && profile) {
+    await emitQueryIndexUpsertEvents(ctx, personQueryIndexEntries(person, profile))
+  }
+}
+
+const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInput, PersonCompanyLinkDeleteResult> = {
   id: 'customers.personCompanyLinks.delete',
   async prepare(rawInput, ctx) {
     const parsed = personCompanyLinkDeleteSchema.parse(rawInput)
+    const profileOnlyTarget = resolveProfileOnlyTarget(parsed)
+    if (profileOnlyTarget) {
+      return {
+        before: {
+          kind: 'profile-only',
+          personEntityId: profileOnlyTarget.personEntityId,
+          companyEntityId: profileOnlyTarget.companyEntityId,
+          tenantId: parsed.tenantId,
+          organizationId: parsed.organizationId,
+        } satisfies PersonCompanyProfileAssignmentSnapshot,
+      }
+    }
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const snapshot = await loadPersonCompanyLinkSnapshot(em, parsed.linkId, {
+    const snapshot = await loadPersonCompanyLinkSnapshot(em, parsed.linkId as string, {
       tenantId: ctx.auth?.tenantId ?? null,
       organizationId: ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null,
     })
@@ -593,11 +797,16 @@ const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInpu
     ensureOrganizationScope(ctx, parsed.organizationId)
 
     const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const profileOnlyTarget = resolveProfileOnlyTarget(parsed)
+    if (profileOnlyTarget) {
+      return await detachProfileOnlyCompany(em, ctx, parsed, profileOnlyTarget)
+    }
+
     const link = await findOneWithDecryption(
       em,
       CustomerPersonCompanyLink,
       {
-        id: parsed.linkId,
+        id: parsed.linkId as string,
         tenantId: parsed.tenantId,
         organizationId: parsed.organizationId,
         deletedAt: null,
@@ -647,13 +856,15 @@ const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInpu
       indexer: { entityType: 'customers:customer_person_company_link' },
     })
 
-    return { linkId: link.id }
+    return { linkId: link.id, personEntityId: personId, companyEntityId: companyId }
   },
   buildLog: async ({ result, snapshots }) => {
     const { translate } = await resolveTranslations()
-    const before = snapshots.before as PersonCompanyLinkSnapshot | undefined
+    const before = snapshots.before as PersonCompanyLinkDeleteSnapshot | undefined
     return {
       actionLabel: translate('customers.audit.personCompanyLinks.delete', 'Remove company link'),
+      // Kept as `customers.personCompanyLink` for the profile-only shape too: the company
+      // detail cache tags this resource kind, so both detach shapes must invalidate it.
       resourceKind: 'customers.personCompanyLink',
       resourceId: result.linkId,
       parentResourceKind: 'customers.person',
@@ -664,15 +875,20 @@ const deletePersonCompanyLinkCommand: CommandHandler<PersonCompanyLinkDeleteInpu
       payload: {
         undo: {
           before: before ?? null,
-        } satisfies PersonCompanyLinkUndoPayload,
+        } satisfies PersonCompanyLinkDeleteUndoPayload,
       },
     }
   },
   undo: async ({ logEntry, ctx }) => {
-    const payload = extractUndoPayload<PersonCompanyLinkUndoPayload>(logEntry)
+    const payload = extractUndoPayload<PersonCompanyLinkDeleteUndoPayload>(logEntry)
     const before = payload?.before
     if (!before) return
 
+    if (isProfileAssignmentSnapshot(before)) {
+      await restoreProfileOnlyCompany(ctx, before)
+      return
+    }
+
     const em = (ctx.container.resolve('em') as EntityManager).fork()
     const link = await findOneWithDecryption(
       em,

package/src/modules/customers/components/CustomerTodosTable.tsx

@@ -47,6 +47,7 @@ type CustomerTodosResponse = {
   page: number
   pageSize: number
   totalPages: number
+  totalIsCapped?: boolean
 }
 
 const TASKS_TAB_QUERY = 'tab=tasks'
@@ -279,6 +280,7 @@ export function CustomerTodosTable(): React.JSX.Element {
         pageSize,
         total: data?.total ?? 0,
         totalPages: data?.totalPages ?? 0,
+        totalIsCapped: data?.totalIsCapped === true,
         onPageChange: setPage,
       }}
       isLoading={isLoading}

package/src/modules/customers/components/DealsKpiStrip.tsx

@@ -63,13 +63,12 @@ export type DealsKpiStripProps = {
   onNeedsAttentionClick?: () => void
 }
 
-const compactNumberFormatter = new Intl.NumberFormat(undefined, {
-  notation: 'compact',
-  maximumFractionDigits: 1,
-})
-
-function formatCompact(value: number): string {
-  return compactNumberFormatter.format(value)
+function createCompactFormatter(locale: string): (value: number) => string {
+  const formatter = new Intl.NumberFormat(locale, {
+    notation: 'compact',
+    maximumFractionDigits: 1,
+  })
+  return (value: number) => formatter.format(value)
 }
 
 function buildCurrencySuffix(code: string | null, convertedAll: boolean): string {
@@ -136,6 +135,7 @@ export function DealsKpiStrip({
 }: DealsKpiStripProps) {
   const t = useT()
   const locale = useLocale()
+  const formatCompact = React.useMemo(() => createCompactFormatter(locale), [locale])
   const pluralCat = React.useCallback((count: number): string => {
     try {
       return new Intl.PluralRules(locale).select(count)

package/src/modules/customers/components/calendar/AgendaList.tsx

@@ -56,7 +56,7 @@ function deriveTypeLabel(interactionType: string): string {
 }
 
 function participantLabel(participant: CalendarItem['participants'][number]): string {
-  return participant.name ?? participant.email ?? participant.userId
+  return participant.name ?? participant.email ?? participant.userId ?? ''
 }
 
 function buildDayGroups(anchor: Date, horizonDays: number, items: CalendarItem[]): AgendaDayGroup[] {
@@ -171,8 +171,8 @@ function AgendaRow({
       <div className="flex shrink-0 items-center gap-2">
         {item.participants.length > 0 ? (
           <span className="hidden items-center gap-0.5 sm:flex">
-            {item.participants.slice(0, MAX_AVATARS_PER_ROW).map((participant) => (
-              <Avatar key={participant.userId} size="xs" label={participantLabel(participant)} />
+            {item.participants.slice(0, MAX_AVATARS_PER_ROW).map((participant, index) => (
+              <Avatar key={participant.userId ?? participant.email ?? index} size="xs" label={participantLabel(participant)} />
             ))}
             {item.participants.length > MAX_AVATARS_PER_ROW ? (
               <span className="ps-0.5 text-xs font-medium text-muted-foreground">

package/src/modules/customers/components/calendar/CalendarEventEditor.tsx

@@ -170,7 +170,7 @@ function EditorBody({
     const ids: string[] = []
     if (form.relatedTo && form.relatedTo.kind !== 'company') ids.push(form.relatedTo.id)
     for (const participant of form.participants) {
-      if (participant.isCustomer) ids.push(participant.userId)
+      if (participant.isCustomer && participant.userId) ids.push(participant.userId)
     }
     return Array.from(new Set(ids))
   }, [form.relatedTo, form.participants])

package/src/modules/customers/components/calendar/CalendarScreen.tsx

@@ -238,7 +238,7 @@ export function CalendarScreen({ resourcesEnabled = false, staffEnabled = true }
     const participantNames = new Map<string, string>()
     for (const item of visibleItems) {
       for (const participant of item.participants) {
-        if (participant.name && !participantNames.has(participant.userId)) {
+        if (participant.userId && participant.name && !participantNames.has(participant.userId)) {
           participantNames.set(participant.userId, participant.name)
         }
       }

package/src/modules/customers/components/calendar/CalendarSettingsModal.tsx

@@ -72,7 +72,7 @@ export function CalendarSettingsModal({
 
   const toggleRows: Array<{ key: ToggleKey; label: string }> = [
     { key: 'showCrmActivities', label: t('customers.calendar.settings.showCrmActivities', 'Show CRM activities on calendar') },
-    { key: 'aiSummaries', label: t('customers.calendar.settings.aiSummaries', 'AI summaries & quick actions') },
+    { key: 'aiSummaries', label: t('customers.calendar.settings.aiSummaries', 'AI summaries') },
     { key: 'conflictWarnings', label: t('customers.calendar.settings.conflictWarnings', 'Conflict warnings') },
     { key: 'showWeekends', label: t('customers.calendar.settings.showWeekends', 'Show weekends') },
   ]

package/src/modules/customers/components/calendar/EventBlock.tsx

@@ -180,8 +180,8 @@ export const EventBlock = React.forwardRef<HTMLButtonElement, EventBlockProps>(f
           {visibleParticipants.length > 0 ? (
             <>
               <AvatarStack size="xs" max={MAX_VISIBLE_AVATARS} className="shrink-0 gap-px [&>*:not(:first-child)]:-ml-1">
-                {visibleParticipants.map((participant) => (
-                  <Avatar key={participant.userId} size="xs" label={participantLabel(participant)} />
+                {visibleParticipants.map((participant, index) => (
+                  <Avatar key={participant.userId ?? participant.email ?? index} size="xs" label={participantLabel(participant)} />
                 ))}
               </AvatarStack>
               {overflowCount > 0 ? (

package/src/modules/customers/components/calendar/EventPeekPopover.tsx

@@ -22,6 +22,7 @@ export type EventPeekPopoverProps = {
   joinUrl: string | null
   aiSummaries: boolean
   canManage?: boolean
+  side?: React.ComponentProps<typeof PopoverContent>['side']
   onOpenChange(open: boolean): void
   onJoin(item: CalendarItem): void
   onEdit(item: CalendarItem): void
@@ -34,6 +35,7 @@ export function EventPeekPopover({
   joinUrl,
   aiSummaries,
   canManage = true,
+  side = 'right',
   onOpenChange,
   onJoin,
   onEdit,
@@ -63,12 +65,12 @@ export function EventPeekPopover({
     (part): part is string => Boolean(part),
   )
   const showSummary = aiSummaries && metaParts.length > 0
-  const showJoin = aiSummaries && Boolean(joinUrl)
+  const showJoin = Boolean(joinUrl)
 
   return (
     <Popover open={open} onOpenChange={onOpenChange}>
       <PopoverTrigger asChild>{children}</PopoverTrigger>
-      <PopoverContent align="start" side="right" sideOffset={8} className="w-56 p-3">
+      <PopoverContent align="start" side={side} sideOffset={8} className="w-56 p-3">
         <div className="flex flex-col gap-2">
           <p className="text-sm font-semibold leading-5 text-foreground">{title}</p>
           <p className="text-xs leading-4 text-muted-foreground">{`${dateLabel} · ${timeRange}`}</p>