@open-mercato/core 0.9.0 → 0.9.1-develop.7459.1.99e3accd30

package/src/modules/customers/lib/calendar/eventTypeResolver.ts

@@ -0,0 +1,258 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { waitForAsyncRegistration } from '@open-mercato/shared/lib/bootstrap/factory'
+import {
+  getInjectionRegistryVersion,
+  loadInjectionWidgetsForSpot,
+} from '@open-mercato/shared/modules/widgets/injection-loader'
+import {
+  calendarEventTypeBehaviorSchema,
+  calendarEventTypes,
+  getCalendarEventTypes,
+  getCalendarEventTypeTombstones,
+  resolveCalendarEventType,
+  registerWidgetCalendarEventTypeContributions,
+  type CalendarEventTypeBehavior,
+  type CalendarEventTypeProvenance,
+  type EffectiveCalendarEventType,
+} from '../../calendar-event-types'
+import { CustomerDictionaryEntry } from '../../data/entities'
+import { extensionPoints } from '../../extension-points'
+
+export type ScopedCalendarEventType = Readonly<{
+  key: string
+  label: string
+  labelKey?: string
+  icon?: string | null
+  color?: string | null
+  behavior: CalendarEventTypeBehavior
+  selectable: boolean
+  panelKey?: string
+  source: string
+  provenance: Readonly<Record<string, CalendarEventTypeProvenance>>
+  historical: boolean
+  fallbackReason?: 'tombstoned' | 'module-unavailable' | 'unknown'
+  adminConfigurable: boolean
+  isInherited: boolean
+  isLocalOverride: boolean
+  updatedAt: string | null
+  missingCustomFieldsetIds: readonly string[]
+  inactiveDictionaryOverride?: boolean
+}>
+
+export type CalendarEventTypeCatalog = Readonly<{
+  items: readonly ScopedCalendarEventType[]
+  fallbackKey: 'meeting'
+}>
+
+type ResolveCalendarEventTypesInput = {
+  em: EntityManager
+  tenantId: string
+  organizationId: string
+  readableOrganizationIds: readonly string[]
+  availableCustomFieldsetIdsFromEntitiesBoundary?: readonly string[]
+}
+
+function deepFreeze<T>(value: T): T {
+  if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+    Object.freeze(value)
+    for (const child of Object.values(value as Record<string, unknown>)) deepFreeze(child)
+  }
+  return value
+}
+
+function serializeStaticType(type: EffectiveCalendarEventType): ScopedCalendarEventType {
+  return deepFreeze({
+    key: type.key,
+    label: type.label,
+    ...(type.labelKey ? { labelKey: type.labelKey } : {}),
+    icon: type.icon ?? null,
+    color: type.color ?? null,
+    behavior: type.behavior,
+    selectable: type.behavior.selectable,
+    ...(type.panelKey ? { panelKey: type.panelKey } : {}),
+    source: type.provenance.key?.moduleId ?? 'customers',
+    provenance: type.provenance,
+    historical: type.historical,
+    ...(type.fallbackReason ? { fallbackReason: type.fallbackReason } : {}),
+    adminConfigurable: type.adminConfigurable !== false,
+    isInherited: false,
+    isLocalOverride: false,
+    updatedAt: null,
+    missingCustomFieldsetIds: [],
+  })
+}
+
+export function resolveBaselineCalendarEventTypes(): CalendarEventTypeCatalog {
+  const types: readonly EffectiveCalendarEventType[] = getCalendarEventTypes()
+  return deepFreeze({ items: types.map(serializeStaticType), fallbackKey: 'meeting' })
+}
+
+let loadedWidgetVersion = -1
+let loadingWidgets: Promise<void> | null = null
+
+async function ensureCalendarEventTypeWidgetsLoaded(): Promise<void> {
+  await waitForAsyncRegistration()
+  const version = getInjectionRegistryVersion()
+  if (loadedWidgetVersion === version) return
+  if (loadingWidgets) return loadingWidgets
+  const pending = (async () => {
+    const widgets = await loadInjectionWidgetsForSpot(extensionPoints.hosts.calendarEventTypes.spotId)
+    registerWidgetCalendarEventTypeContributions(widgets.map((widget) => {
+      return {
+        moduleId: widget.moduleId,
+        widgetId: widget.metadata.id,
+        priority: typeof widget.placement?.priority === 'number' ? widget.placement.priority : 0,
+        definitions: 'eventTypes' in widget ? widget.eventTypes : null,
+        overrides: 'eventTypeOverrides' in widget ? widget.eventTypeOverrides : undefined,
+        patches: 'eventTypePatches' in widget ? widget.eventTypePatches : undefined,
+      }
+    }))
+    loadedWidgetVersion = version
+  })()
+  loadingWidgets = pending
+  try {
+    await pending
+  } finally {
+    if (loadingWidgets === pending) loadingWidgets = null
+  }
+}
+
+function selectDictionaryRows(
+  rows: readonly CustomerDictionaryEntry[],
+  organizationId: string,
+  readableOrganizationIds: readonly string[],
+): Map<string, CustomerDictionaryEntry> {
+  const orderedOrganizationIds = Array.from(new Set([organizationId, ...readableOrganizationIds]))
+  const rank = new Map(orderedOrganizationIds.map((id, index) => [id, index]))
+  const sorted = [...rows].sort((left, right) => {
+    const rankDelta = (rank.get(left.organizationId) ?? Number.MAX_SAFE_INTEGER) -
+      (rank.get(right.organizationId) ?? Number.MAX_SAFE_INTEGER)
+    return rankDelta || left.normalizedValue.localeCompare(right.normalizedValue)
+  })
+  const selected = new Map<string, CustomerDictionaryEntry>()
+  for (const row of sorted) {
+    const key = row.normalizedValue.trim() || row.value.trim().toLowerCase()
+    if (key && !selected.has(key)) selected.set(key, row)
+  }
+  return selected
+}
+
+function isUnchangedShippedDictionaryRow(row: CustomerDictionaryEntry, key: string): boolean {
+  const shipped = calendarEventTypes.find((entry) => entry.key === key)
+  return !!shipped && !row.activityTypeBehavior && row.label === shipped.label &&
+    row.icon === shipped.icon && row.color === shipped.color
+}
+
+export async function resolveScopedCalendarEventTypes(
+  input: ResolveCalendarEventTypesInput,
+): Promise<CalendarEventTypeCatalog> {
+  await ensureCalendarEventTypeWidgetsLoaded()
+  const scopeOrganizationIds = Array.from(new Set([input.organizationId, ...input.readableOrganizationIds]))
+  const rows = await findWithDecryption(
+    input.em,
+    CustomerDictionaryEntry,
+    {
+      tenantId: input.tenantId,
+      organizationId: { $in: scopeOrganizationIds },
+      kind: 'activity_type',
+    },
+    { orderBy: { label: 'asc' } },
+    { tenantId: input.tenantId, organizationId: input.organizationId },
+  )
+  const dictionaryRows = selectDictionaryRows(rows, input.organizationId, scopeOrganizationIds)
+  for (const [key, row] of dictionaryRows) {
+    if (isUnchangedShippedDictionaryRow(row, key)) dictionaryRows.delete(key)
+  }
+  const staticCatalog = resolveBaselineCalendarEventTypes()
+  const availableFieldsets = input.availableCustomFieldsetIdsFromEntitiesBoundary
+    ? new Set(input.availableCustomFieldsetIdsFromEntitiesBoundary)
+    : null
+  const staticByKey = new Map(staticCatalog.items.map((item) => [item.key, item]))
+  const tombstonedKeys = new Set(getCalendarEventTypeTombstones().map((entry) => entry.key))
+  const keys = new Set([...staticByKey.keys(), ...[...dictionaryRows.keys()].filter((key) => !tombstonedKeys.has(key))])
+  const fallbackBehavior = calendarEventTypes[0]!.behavior
+  const items = [...keys].map((key): ScopedCalendarEventType => {
+    const base = staticByKey.get(key)
+    const row = dictionaryRows.get(key)
+    if (!row) {
+      if (!availableFieldsets) return base!
+      return deepFreeze({
+        ...base!,
+        missingCustomFieldsetIds: base!.behavior.customFieldsetIds.filter((id) => !availableFieldsets.has(id)),
+      })
+    }
+    if (base?.adminConfigurable === false) {
+      return deepFreeze({
+        ...base,
+        inactiveDictionaryOverride: true,
+      })
+    }
+    const parsedBehavior = row.activityTypeBehavior
+      ? calendarEventTypeBehaviorSchema.safeParse(row.activityTypeBehavior)
+      : null
+    const behavior = parsedBehavior?.success
+      ? parsedBehavior.data
+      : base?.behavior ?? { ...fallbackBehavior, selectable: true }
+    const isLocalOverride = row.organizationId === input.organizationId
+    const defaultLabel = calendarEventTypes.find((entry) => entry.key === key)?.label ?? base?.label
+    const hasCustomLabel = !!row.label && row.label !== defaultLabel
+    return deepFreeze({
+      key,
+      label: hasCustomLabel ? row.label : base?.label || row.label || row.value,
+      ...(!hasCustomLabel && base?.labelKey ? { labelKey: base.labelKey } : {}),
+      icon: row.icon ?? base?.icon ?? null,
+      color: row.color ?? base?.color ?? null,
+      behavior,
+      selectable: behavior.selectable,
+      ...(base?.panelKey ? { panelKey: base.panelKey } : {}),
+      source: base?.source ?? 'dictionary',
+      provenance: base?.provenance ?? {},
+      historical: false,
+      adminConfigurable: true,
+      isInherited: !isLocalOverride,
+      isLocalOverride,
+      updatedAt: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : null,
+      missingCustomFieldsetIds: availableFieldsets
+        ? behavior.customFieldsetIds.filter((id) => !availableFieldsets.has(id))
+        : [],
+    })
+  })
+  items.sort((left, right) => left.behavior.order - right.behavior.order || left.key.localeCompare(right.key))
+  return deepFreeze({ items, fallbackKey: 'meeting' })
+}
+
+export function resolveCatalogEventType(
+  catalog: CalendarEventTypeCatalog,
+  key: string,
+  options: { includeHistorical?: boolean } = {},
+): ScopedCalendarEventType | undefined {
+  const normalizedKey = key.trim().toLowerCase()
+  const item = catalog.items.find((entry) => entry.key === normalizedKey)
+  if (item || !options.includeHistorical) return item
+  const registryHistorical = resolveCalendarEventType(key, { includeHistorical: true })
+  if (registryHistorical) {
+    const serialized = serializeStaticType(registryHistorical)
+    return deepFreeze({
+      ...serialized,
+      selectable: false,
+      behavior: { ...serialized.behavior, selectable: false },
+      historical: true,
+    })
+  }
+  const fallback = catalog.items.find((entry) => entry.key === catalog.fallbackKey)
+  if (!fallback) return undefined
+  return deepFreeze({
+    ...fallback,
+    key,
+    label: key,
+    labelKey: undefined,
+    behavior: { ...fallback.behavior, selectable: false },
+    selectable: false,
+    historical: true,
+    source: 'historical-fallback',
+    isInherited: false,
+    isLocalOverride: false,
+    updatedAt: null,
+  })
+}

package/src/modules/customers/lib/calendar/interactionApplicability.ts

@@ -0,0 +1,99 @@
+import type { CalendarEventTypeBehavior } from '../../calendar-event-types'
+
+export type InteractionCoreValues = Readonly<Record<string, unknown>>
+
+const CORE_FIELD_RULES: readonly [keyof CalendarEventTypeBehavior['fields'], readonly string[]][] = [
+  ['endTime', ['durationMinutes']],
+  ['allDay', ['allDay']],
+  ['recurrence', ['recurrenceRule', 'recurrenceEnd']],
+  ['priority', ['priority']],
+]
+
+function hasValue(value: unknown): boolean {
+  if (value === null || value === undefined || value === '' || value === false) return false
+  if (Array.isArray(value)) return value.length > 0
+  return true
+}
+
+function hasResourceLinks(value: unknown): boolean {
+  return Array.isArray(value) && value.some((link) =>
+    link !== null && typeof link === 'object' && 'type' in link && link.type === 'resource')
+}
+
+export function findInapplicableCoreFields(
+  behavior: CalendarEventTypeBehavior,
+  values: InteractionCoreValues,
+): string[] {
+  const fields: string[] = []
+  for (const [rule, names] of CORE_FIELD_RULES) {
+    if (behavior.fields[rule]) continue
+    for (const name of names) if (hasValue(values[name])) fields.push(name)
+  }
+  if (behavior.fields.location === 'none' && hasValue(values.location)) fields.push('location')
+  if (behavior.fields.people === 'none' && hasValue(values.participants)) fields.push('participants')
+  if (!behavior.fields.resources && hasResourceLinks(values.linkedEntities)) fields.push('linkedEntities')
+  return fields
+}
+
+export function clearInapplicableCoreFields(
+  behavior: CalendarEventTypeBehavior,
+  values: InteractionCoreValues,
+): Record<string, unknown> {
+  const cleared: Record<string, unknown> = {}
+  for (const field of findInapplicableCoreFields(behavior, values)) {
+    if (field === 'linkedEntities') {
+      cleared.linkedEntities = (values.linkedEntities as readonly Record<string, unknown>[])
+        .filter((link) => link.type !== 'resource')
+    } else {
+      cleared[field] = null
+    }
+  }
+  return cleared
+}
+
+/**
+ * Under the selectable-type opt-in an explicit `null` for a field the type hides
+ * means "not shown", not "clear it". Dropping it lets a type change judge the
+ * stored value, so the destructive clear is confirmed instead of silent.
+ */
+export function omitHiddenCoreClears(
+  behavior: CalendarEventTypeBehavior,
+  patch: InteractionCoreValues,
+): Record<string, unknown> {
+  const result = { ...patch }
+  for (const [rule, names] of CORE_FIELD_RULES) {
+    if (behavior.fields[rule]) continue
+    for (const name of names) if (result[name] === null) delete result[name]
+  }
+  if (behavior.fields.location === 'none' && result.location === null) delete result.location
+  if (behavior.fields.people === 'none' && result.participants === null) delete result.participants
+  return result
+}
+
+/**
+ * `ignoreHiddenClears` belongs to the selectable-type opt-in: only a caller that
+ * declares `enforceSelectableType` has its explicit `null` clears of fields the
+ * type hides dropped. Retaining stored resource links is unconditional — it
+ * protects bookings a partial payload never meant to release.
+ */
+export function preserveHiddenCoreValuesOnSameTypeEdit(
+  behavior: CalendarEventTypeBehavior,
+  current: InteractionCoreValues,
+  patch: InteractionCoreValues,
+  options: { ignoreHiddenClears?: boolean } = { ignoreHiddenClears: true },
+): Record<string, unknown> {
+  const result = options.ignoreHiddenClears !== false ? omitHiddenCoreClears(behavior, patch) : { ...patch }
+  if (!behavior.fields.resources && result.linkedEntities !== undefined) {
+    const existingLinks = Array.isArray(current.linkedEntities) ? current.linkedEntities : []
+    const retainedResources = existingLinks.filter((link) =>
+      link !== null && typeof link === 'object' && 'type' in link && link.type === 'resource')
+    const nextLinks = Array.isArray(result.linkedEntities) ? result.linkedEntities : []
+    const sentResourceIds = new Set(nextLinks.flatMap((link) =>
+      link !== null && typeof link === 'object' && 'type' in link && link.type === 'resource' && 'id' in link ? [link.id] : []))
+    result.linkedEntities = [
+      ...nextLinks,
+      ...retainedResources.filter((link) => !('id' in link) || !sentResourceIds.has(link.id)),
+    ]
+  }
+  return result
+}

package/src/modules/customers/lib/calendar/mapItem.ts

@@ -11,6 +11,7 @@ import type {
 } from '../../components/calendar/types'
 import { categoryOf } from './categories'
 import { participantActorKey } from './participantIdentity'
+import { calendarDayEndInstant, calendarDayStartInstant, calendarInstantToWallTime, isCalendarTimezone } from './timezone'
 
 const DEFAULT_DURATION_MINUTES = 30
 
@@ -70,8 +71,11 @@ export function mapInteractionToCalendarItem(
 
   const allDay = payload.allDay === true
   const durationMinutes = payload.durationMinutes ?? DEFAULT_DURATION_MINUTES
-  const start = allDay ? startOfDay(parsedStart) : parsedStart
-  const end = allDay ? endOfDay(parsedStart) : addMinutes(parsedStart, durationMinutes)
+  const eventDate = allDay && isCalendarTimezone(payload.timezone) ? calendarInstantToWallTime(parsedStart, payload.timezone).date : null
+  const start = eventDate ? calendarDayStartInstant(eventDate, payload.timezone as string) : allDay ? startOfDay(parsedStart) : parsedStart
+  const end = eventDate ? calendarDayEndInstant(eventDate, payload.timezone as string) : allDay ? endOfDay(parsedStart) : addMinutes(parsedStart, durationMinutes)
+
+  if (!start || !end) return null
 
   const location = payload.location ?? null
   const platform = detectPlatform(location)

package/src/modules/customers/lib/calendar/recurrence.ts

@@ -1,7 +1,9 @@
 import { addDays } from 'date-fns/addDays'
+import { calendarDayEndInstant, calendarDayStartInstant, calendarInstantToWallTime, calendarRecurrenceWallTimeToInstant, isCalendarTimezone } from './timezone'
 import type { CalendarItem, CalendarRange } from '../../components/calendar/types'
 
 const MAX_OCCURRENCES_PER_WINDOW = 100
+const DAY_MS = 24 * 60 * 60 * 1000
 
 const WEEKDAY_TOKENS = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'] as const
 
@@ -92,15 +94,70 @@ function parseRecurrenceEndTime(rawRecurrenceEnd: string | null | undefined): nu
 
 function occursOn(date: Date, rule: ParsedRecurrenceRule, seriesStartWeekday: number): boolean {
   if (rule.freq === 'DAILY') return true
-  const allowedWeekdays = rule.byDay ?? [seriesStartWeekday]
+  const allowedWeekdays = [...new Set(rule.byDay ?? [seriesStartWeekday])]
   return allowedWeekdays.includes(date.getDay())
 }
 
+function countMatchingDays(startDay: number, endDay: number, rule: ParsedRecurrenceRule, seriesStartWeekday: number): number {
+  const dayCount = Math.max(0, endDay - startDay)
+  if (rule.freq === 'DAILY') return dayCount
+  const allowedWeekdays = [...new Set(rule.byDay ?? [seriesStartWeekday])]
+  const fullWeeks = Math.floor(dayCount / 7)
+  let matches = fullWeeks * allowedWeekdays.length
+  const remainder = dayCount % 7
+  const startWeekday = new Date(startDay * DAY_MS).getUTCDay()
+  for (let offset = 0; offset < remainder; offset += 1) {
+    if (allowedWeekdays.includes((startWeekday + offset) % 7)) matches += 1
+  }
+  return matches
+}
+
+function utcDay(date: Date): number {
+  return Math.floor(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()) / DAY_MS)
+}
+
+function expandZonedOccurrences(item: CalendarItem, range: CalendarRange, rule: ParsedRecurrenceRule, timezone: string): CalendarItem[] {
+  const startWall = calendarInstantToWallTime(item.start, timezone)
+  const cursor = new Date(`${startWall.date}T00:00:00Z`)
+  const seriesStartDay = Math.floor(cursor.getTime() / DAY_MS)
+  const earliestRelevant = new Date(range.from.getTime() - Math.max(0, item.end.getTime() - item.start.getTime()))
+  const earliestWallDate = calendarInstantToWallTime(earliestRelevant, timezone).date
+  const earliestDay = Math.floor(new Date(`${earliestWallDate}T00:00:00Z`).getTime() / DAY_MS)
+  const finalDate = calendarInstantToWallTime(range.to, timezone).date
+  const seriesWeekday = cursor.getUTCDay()
+  const duration = item.end.getTime() - item.start.getTime()
+  const recurrenceEnd = typeof item.raw.recurrenceEnd === 'string' ? new Date(item.raw.recurrenceEnd).getTime() : null
+  const occurrences: CalendarItem[] = []
+  let occurrenceIndex = 0
+  if (earliestDay > seriesStartDay) {
+    occurrenceIndex = countMatchingDays(seriesStartDay, earliestDay, rule, seriesWeekday)
+    cursor.setUTCDate(cursor.getUTCDate() + earliestDay - seriesStartDay)
+  }
+  while (cursor.toISOString().slice(0, 10) <= finalDate) {
+    const date = cursor.toISOString().slice(0, 10)
+    const start = item.allDay ? calendarDayStartInstant(date, timezone) : calendarRecurrenceWallTimeToInstant(date, startWall.time, timezone)
+    if (start && ((rule.until && start > rule.until) || (recurrenceEnd !== null && start.getTime() > recurrenceEnd))) break
+    const matches = rule.freq === 'DAILY' || (rule.byDay ?? [seriesWeekday]).includes(cursor.getUTCDay())
+    if (start && matches) {
+      if (rule.count !== null && occurrenceIndex >= rule.count) break
+      const end = item.allDay ? calendarDayEndInstant(date, timezone) : new Date(start.getTime() + duration)
+      if (end && start <= range.to && end > range.from) {
+        occurrences.push({ ...item, id: `${item.id}:${occurrenceIndex}`, start, end, isRecurringOccurrence: true })
+        if (occurrences.length >= MAX_OCCURRENCES_PER_WINDOW) break
+      }
+      occurrenceIndex += 1
+    }
+    cursor.setUTCDate(cursor.getUTCDate() + 1)
+  }
+  return occurrences
+}
+
 export function expandOccurrences(item: CalendarItem, range: CalendarRange): CalendarItem[] {
   const rawRule = item.raw.recurrenceRule
   if (typeof rawRule !== 'string' || rawRule.trim().length === 0) return [item]
   const rule = parseRecurrenceRule(rawRule)
   if (!rule) return [item]
+  if (isCalendarTimezone(item.raw.timezone)) return expandZonedOccurrences(item, range, rule, item.raw.timezone)
 
   const durationMs = item.end.getTime() - item.start.getTime()
   const recurrenceEndTime = parseRecurrenceEndTime(item.raw.recurrenceEnd)
@@ -110,6 +167,13 @@ export function expandOccurrences(item: CalendarItem, range: CalendarRange): Cal
   const occurrences: CalendarItem[] = []
   let occurrenceIndex = 0
   let cursor = new Date(item.start)
+  const seriesStartDay = utcDay(cursor)
+  const earliestRelevant = new Date(range.from.getTime() - Math.max(0, durationMs))
+  const earliestDay = utcDay(earliestRelevant)
+  if (earliestDay > seriesStartDay) {
+    occurrenceIndex = countMatchingDays(seriesStartDay, earliestDay, rule, seriesStartWeekday)
+    cursor = addDays(cursor, earliestDay - seriesStartDay)
+  }
 
   while (cursor.getTime() <= range.to.getTime()) {
     if (untilTime !== null && cursor.getTime() > untilTime) break

package/src/modules/customers/lib/calendar/timezone.ts

@@ -0,0 +1,117 @@
+const formatters = new Map<string, Intl.DateTimeFormat>()
+
+function parseWallTime(date: string, time: string): Date | null {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || !/^\d{2}:\d{2}$/.test(time)) return null
+  const wall = new Date(`${date}T${time}:00Z`)
+  if (!Number.isFinite(wall.getTime()) || wall.toISOString().slice(0, 16) !== `${date}T${time}`) return null
+  return wall
+}
+
+function calendarTimezoneOffsets(wall: Date, timezone: string): number[] {
+  const offsets = new Set<number>()
+  for (const hour of [-36, -12, 0, 12, 36]) {
+    const sample = new Date(wall.getTime() + hour * 3600000)
+    const local = calendarInstantToWallTime(sample, timezone)
+    offsets.add(new Date(`${local.date}T${local.time}:00Z`).getTime() - sample.getTime())
+  }
+  return [...offsets]
+}
+
+export function isCalendarTimezone(value: unknown): value is string {
+  if (typeof value !== 'string' || !value.trim() || value.length > 120 || /^[+-]/.test(value)) return false
+  try {
+    formatter(value).format()
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * IANA zone ids are case-insensitive, so `europe/warsaw` and `Europe/Warsaw` are
+ * the same zone and would otherwise be stored — and listed — as two options.
+ * Canonicalize on write so the stored value matches the catalog spelling.
+ */
+export function canonicalCalendarTimezone(value: unknown): string | null {
+  if (!isCalendarTimezone(value)) return null
+  const resolved = formatter(value).resolvedOptions().timeZone
+  return isCalendarTimezone(resolved) ? resolved : value
+}
+
+export function defaultCalendarTimezone(): string {
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone
+  return isCalendarTimezone(timezone) ? timezone : 'UTC'
+}
+
+function formatter(timezone: string): Intl.DateTimeFormat {
+  let result = formatters.get(timezone)
+  if (!result) {
+    result = new Intl.DateTimeFormat('en-CA', { timeZone: timezone, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23' })
+    if (formatters.size >= 64) formatters.delete(formatters.keys().next().value!)
+    formatters.set(timezone, result)
+  }
+  return result
+}
+
+export function calendarInstantToWallTime(instant: Date, timezone: string): { date: string; time: string } {
+  const parts = formatter(timezone).formatToParts(instant)
+  const part = (name: string) => parts.find((entry) => entry.type === name)!.value
+  return { date: `${part('year')}-${part('month')}-${part('day')}`, time: `${part('hour')}:${part('minute')}` }
+}
+
+export function calendarWallTimeToInstant(date: string, time: string, timezone: string): Date | null {
+  if (!isCalendarTimezone(timezone)) return null
+  const wall = parseWallTime(date, time)
+  if (!wall) return null
+  const candidates = calendarTimezoneOffsets(wall, timezone).map((offset) => new Date(wall.getTime() - offset))
+    .filter((instant) => {
+      const local = calendarInstantToWallTime(instant, timezone)
+      return local.date === date && local.time === time
+    }).sort((left, right) => left.getTime() - right.getTime())
+  return candidates[0] ?? null
+}
+
+export function calendarRecurrenceWallTimeToInstant(date: string, time: string, timezone: string): Date | null {
+  const exact = calendarWallTimeToInstant(date, time, timezone)
+  if (exact) return exact
+  if (!isCalendarTimezone(timezone) || !calendarDayStartInstant(date, timezone)) return null
+  const wall = parseWallTime(date, time)
+  if (!wall) return null
+  const offsets = calendarTimezoneOffsets(wall, timezone)
+  if (offsets.length < 2) return null
+  return new Date(wall.getTime() - Math.min(...offsets))
+}
+
+export function calendarDayStartInstant(date: string, timezone: string): Date | null {
+  if (!isCalendarTimezone(timezone) || !/^\d{4}-\d{2}-\d{2}$/.test(date)) return null
+  const anchor = new Date(`${date}T00:00:00Z`)
+  if (!Number.isFinite(anchor.getTime()) || anchor.toISOString().slice(0, 10) !== date) return null
+  const midnight = calendarWallTimeToInstant(date, '00:00', timezone)
+  if (midnight) return midnight
+  let lower = anchor.getTime() - 36 * 3600000
+  let upper = anchor.getTime() + 36 * 3600000
+  while (lower < upper) {
+    const middle = lower + Math.floor((upper - lower) / 2)
+    if (calendarInstantToWallTime(new Date(middle), timezone).date < date) lower = middle + 1
+    else upper = middle
+  }
+  const boundary = new Date(lower)
+  return calendarInstantToWallTime(boundary, timezone).date === date ? boundary : null
+}
+
+export function calendarDayEndInstant(date: string, timezone: string): Date | null {
+  if (!calendarDayStartInstant(date, timezone)) return null
+  const nextDate = new Date(`${date}T00:00:00Z`)
+  for (let skippedDays = 0; skippedDays < 3; skippedDays += 1) {
+    nextDate.setUTCDate(nextDate.getUTCDate() + 1)
+    const nextBoundary = calendarDayStartInstant(nextDate.toISOString().slice(0, 10), timezone)
+    if (nextBoundary) return new Date(nextBoundary.getTime() - 1)
+  }
+  return null
+}
+
+export function calendarTimezoneOptions(storedTimezone?: string | null): string[] {
+  const intl = Intl as typeof Intl & { supportedValuesOf?: (key: 'timeZone') => string[] }
+  const stored = isCalendarTimezone(storedTimezone) ? [storedTimezone] : []
+  return [...new Set(['UTC', defaultCalendarTimezone(), ...stored, ...(intl.supportedValuesOf?.('timeZone') ?? [])])]
+}

package/src/modules/customers/lib/interactionReadModel.ts

@@ -189,6 +189,7 @@ export async function hydrateCanonicalInteractions({
       appearanceColor: interaction.appearanceColor ?? null,
       source: interaction.source ?? null,
       duration: interaction.durationMinutes ?? null,
+      timezone: interaction.timezone ?? null,
       location: interaction.location ?? null,
       allDay: interaction.allDay ?? null,
       recurrenceRule: interaction.recurrenceRule ?? null,

package/src/modules/customers/lib/todoCompatibility.ts

@@ -28,6 +28,7 @@ export type CustomerTodoRow = {
   todoSeverity?: string | null
   todoDescription?: string | null
   todoDueAt?: string | null
+  todoTimezone?: string | null
   todoCustomValues?: Record<string, unknown> | null
   todoOrganizationId: string | null
   todoUpdatedAt?: string | null
@@ -640,6 +641,7 @@ export function mapInteractionRecordToTodoRow(
         : null,
     todoDescription: interaction.body ?? null,
     todoDueAt: interaction.scheduledAt ?? null,
+    todoTimezone: interaction.timezone ?? null,
     todoCustomValues: Object.keys(customValues).length > 0 ? customValues : null,
     todoOrganizationId: interaction.organizationId ?? null,
     todoUpdatedAt: interaction.updatedAt ?? null,

package/src/modules/customers/migrations/.snapshot-open-mercato.json

@@ -2528,6 +2528,23 @@
       "name": "customer_dictionary_entries",
       "schema": "public",
       "columns": {
+        "activity_type_behavior": {
+          "name": "activity_type_behavior",
+          "type": "jsonb",
+          "unsigned": false,
+          "autoincrement": false,
+          "primary": false,
+          "nullable": true,
+          "unique": false,
+          "length": null,
+          "precision": null,
+          "scale": null,
+          "default": null,
+          "comment": null,
+          "collation": null,
+          "enumItems": [],
+          "mappedType": "json"
+        },
         "color": {
           "name": "color",
           "type": "text",
@@ -4435,6 +4452,23 @@
           "collation": null,
           "enumItems": [],
           "mappedType": "text"
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "text",
+          "unsigned": false,
+          "autoincrement": false,
+          "primary": false,
+          "nullable": true,
+          "unique": false,
+          "length": null,
+          "precision": null,
+          "scale": null,
+          "default": null,
+          "comment": null,
+          "collation": null,
+          "enumItems": [],
+          "mappedType": "text"
         }
       },
       "indexes": [

package/src/modules/customers/migrations/Migration20260928175058_customers.ts

@@ -0,0 +1,15 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260928175058_customers extends Migration {
+
+  override name = 'Migration20260928175058_customers';
+
+  override up(): void | Promise<void> {
+    this.addSql(`alter table "customer_dictionary_entries" add "activity_type_behavior" jsonb null;`);
+  }
+
+  override down(): void | Promise<void> {
+    this.addSql(`alter table "customer_dictionary_entries" drop column "activity_type_behavior";`);
+  }
+
+}