@soulbatical/tetra-core 0.10.4 → 0.11.0

package/dist/shared/planner/PlannerService.js

@@ -1,1393 +0,0 @@
-/**
- * PlannerService — Core scheduling logic
- *
- * Handles:
- * - Availability CRUD (multiple blocks per day)
- * - Appointment CRUD with conflict detection
- * - Vacation-aware slot computation
- * - Team availability aggregation
- * - Scheduler settings management
- *
- * Usage:
- * ```typescript
- * import { PlannerService } from '@soulbatical/tetra-core';
- *
- * const planner = new PlannerService(config);
- * const slots = await planner.getAvailableSlots(db, ownerId, '2026-03-20');
- * ```
- */
-import { buildScheduleIntervals, buildAppointmentIntervals, buildVacationIntervals, unionIntervals, subtractIntervals, intervalsToSlots, splitIntoSlots, } from './intervals.js';
-import { createLogger } from '../../utils/logger.js';
-const logger = createLogger('planner:service');
-// ─── Time Helpers ───────────────────────────────────────────
-export function timeToMinutes(time) {
-    const parts = time.split(':');
-    return parseInt(parts[0], 10) * 60 + parseInt(parts[1], 10);
-}
-export function minutesToTime(minutes) {
-    const hh = String(Math.floor(minutes / 60)).padStart(2, '0');
-    const mm = String(minutes % 60).padStart(2, '0');
-    return `${hh}:${mm}`;
-}
-/**
- * Compute bookable time slots from availability windows, minus existing appointments.
- *
- * Pure function — no DB access.
- *
- * Dedupes on start time: overlapping or adjacent availability windows
- * (e.g. 09:00–17:00 + 13:00–17:00 on the same day) previously produced
- * duplicate slots in the output, so the UI would render entries like
- * "16:00, 16:00". The returned list is chronologically sorted.
- */
-export function computeAvailableSlots(availabilitySlots, existingAppointments, date, slotDurationMinutes = 60) {
-    const seenStarts = new Set();
-    const bookableSlots = [];
-    for (const slot of availabilitySlots) {
-        if (!slot.is_available)
-            continue;
-        const slotStartMinutes = timeToMinutes(slot.start_time);
-        const slotEndMinutes = timeToMinutes(slot.end_time);
-        let cursor = slotStartMinutes;
-        while (cursor + slotDurationMinutes <= slotEndMinutes) {
-            const candidateStart = cursor;
-            const candidateEnd = cursor + slotDurationMinutes;
-            if (seenStarts.has(candidateStart)) {
-                cursor += slotDurationMinutes;
-                continue;
-            }
-            const isBlocked = existingAppointments.some((appt) => {
-                const apptDate = appt.start_time.substring(0, 10);
-                if (apptDate !== date)
-                    return false;
-                const apptStartMinutes = timeToMinutes(appt.start_time.substring(11, 16));
-                const apptEndMinutes = timeToMinutes(appt.end_time.substring(11, 16));
-                return candidateStart < apptEndMinutes && candidateEnd > apptStartMinutes;
-            });
-            if (!isBlocked) {
-                bookableSlots.push({
-                    startTime: minutesToTime(candidateStart),
-                    endTime: minutesToTime(candidateEnd),
-                    _start: candidateStart,
-                });
-                seenStarts.add(candidateStart);
-            }
-            cursor += slotDurationMinutes;
-        }
-    }
-    return bookableSlots
-        .sort((a, b) => a._start - b._start)
-        .map(({ startTime, endTime }) => ({ startTime, endTime }));
-}
-// ─── Row Transformers ───────────────────────────────────────
-function transformAppointment(row, config) {
-    const parentTable = config.parentResource?.table;
-    return {
-        id: row.id,
-        organizationId: row.organization_id,
-        parentId: row.parent_id,
-        organizerId: row.organizer_id,
-        title: row.title,
-        description: row.description,
-        startTime: row.start_time,
-        endTime: row.end_time,
-        location: row.location,
-        type: row.type,
-        status: row.status,
-        attendeeIds: row.attendee_ids || [],
-        googleCalendarEventId: row.google_calendar_event_id,
-        outlookEventId: row.outlook_event_id,
-        reminderSentAt: row.reminder_sent_at,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-        organizer: row.organizer_name !== undefined
-            ? { id: row.organizer_id, name: row.organizer_name, email: row.organizer_email }
-            : (row.organizer ? { id: row.organizer_id, name: row.organizer?.name, email: row.organizer?.email } : null),
-        parent: row.parent_title !== undefined
-            ? { id: row.parent_id, title: row.parent_title }
-            : (row.parent ? { id: row.parent_id, title: row.parent?.title } : null),
-    };
-}
-// ─── Service Class ──────────────────────────────────────────
-export class PlannerService {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    get ownerRoles() {
-        const r = this.config.ownerRole;
-        return Array.isArray(r) ? r : [r];
-    }
-    get ownerTable() {
-        return this.config.ownerTable || 'users_public';
-    }
-    get timezone() {
-        return this.config.timezone || 'Europe/Amsterdam';
-    }
-    get appointmentTypes() {
-        return this.config.appointmentTypes || ['online', 'phone', 'in_person'];
-    }
-    get appointmentStatuses() {
-        return this.config.appointmentStatuses || ['scheduled', 'completed', 'cancelled'];
-    }
-    // ─── Availability ───────────────────────────────────────────
-    /**
-     * Get an owner's recurring availability slots.
-     */
-    async getAvailability(db, ownerId) {
-        const { data, error } = await db
-            .from('planner_availability_slots')
-            .select('*')
-            .eq('owner_id', ownerId)
-            .order('day_of_week', { ascending: true })
-            .order('start_time', { ascending: true });
-        if (error) {
-            logger.error({ error, ownerId }, 'Failed to get availability');
-            throw new Error('Failed to retrieve availability');
-        }
-        return (data || []).map((row) => ({
-            id: row.id,
-            organizationId: row.organization_id,
-            ownerId: row.owner_id,
-            dayOfWeek: row.day_of_week,
-            startTime: row.start_time,
-            endTime: row.end_time,
-            isAvailable: row.is_available,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        }));
-    }
-    /**
-     * Replace all availability slots for an owner.
-     */
-    async setAvailability(db, ownerId, organizationId, slots) {
-        // Validate
-        for (let i = 0; i < slots.length; i++) {
-            const slot = slots[i];
-            if (slot.dayOfWeek < 0 || slot.dayOfWeek > 6) {
-                throw new Error(`Slot ${i}: dayOfWeek must be 0-6`);
-            }
-            if (!slot.startTime || !slot.endTime) {
-                throw new Error(`Slot ${i}: startTime and endTime are required`);
-            }
-            if (timeToMinutes(slot.startTime) >= timeToMinutes(slot.endTime)) {
-                throw new Error(`Slot ${i}: endTime must be after startTime`);
-            }
-        }
-        // Delete existing
-        const { error: deleteError } = await db
-            .from('planner_availability_slots')
-            .delete()
-            .eq('owner_id', ownerId);
-        if (deleteError) {
-            logger.error({ error: deleteError, ownerId }, 'Failed to clear availability');
-            throw new Error('Failed to update availability');
-        }
-        if (slots.length === 0)
-            return [];
-        // Insert new
-        const insertRows = slots.map((slot) => ({
-            organization_id: organizationId,
-            owner_id: ownerId,
-            day_of_week: slot.dayOfWeek,
-            start_time: slot.startTime,
-            end_time: slot.endTime,
-            is_available: slot.isAvailable !== undefined ? slot.isAvailable : true,
-        }));
-        const { data, error: insertError } = await db
-            .from('planner_availability_slots')
-            .insert(insertRows)
-            .select();
-        if (insertError) {
-            logger.error({ error: insertError, ownerId }, 'Failed to insert availability');
-            throw new Error('Failed to save availability');
-        }
-        logger.info({ ownerId, slotCount: slots.length }, 'Availability updated');
-        return data || [];
-    }
-    // ─── Vacations ──────────────────────────────────────────────
-    /**
-     * Check if a date falls within any vacation for an owner.
-     */
-    async isOnVacation(db, ownerId, date) {
-        const { data, error } = await db
-            .from('planner_vacations')
-            .select('id')
-            .eq('owner_id', ownerId)
-            .lte('start_date', date)
-            .gte('end_date', date)
-            .limit(1);
-        if (error) {
-            logger.error({ error, ownerId, date }, 'Failed to check vacation');
-            return false;
-        }
-        return (data || []).length > 0;
-    }
-    /**
-     * Get all vacations for an owner.
-     */
-    async getVacations(db, ownerId) {
-        const { data, error } = await db
-            .from('planner_vacations')
-            .select('*')
-            .eq('owner_id', ownerId)
-            .order('start_date', { ascending: true });
-        if (error) {
-            logger.error({ error, ownerId }, 'Failed to get vacations');
-            throw new Error('Failed to retrieve vacations');
-        }
-        return (data || []).map((row) => ({
-            id: row.id,
-            organizationId: row.organization_id,
-            ownerId: row.owner_id,
-            startDate: row.start_date,
-            endDate: row.end_date,
-            description: row.description,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        }));
-    }
-    /**
-     * Create a vacation period.
-     */
-    async createVacation(db, ownerId, organizationId, startDate, endDate, description) {
-        if (startDate > endDate) {
-            throw new Error('endDate must be on or after startDate');
-        }
-        const { data, error } = await db
-            .from('planner_vacations')
-            .insert({
-            organization_id: organizationId,
-            owner_id: ownerId,
-            start_date: startDate,
-            end_date: endDate,
-            description: description || null,
-        })
-            .select()
-            .single();
-        if (error) {
-            logger.error({ error, ownerId }, 'Failed to create vacation');
-            throw new Error('Failed to create vacation');
-        }
-        logger.info({ ownerId, startDate, endDate }, 'Vacation created');
-        return data;
-    }
-    /**
-     * Delete a vacation.
-     */
-    async deleteVacation(db, vacationId) {
-        const { error } = await db
-            .from('planner_vacations')
-            .delete()
-            .eq('id', vacationId);
-        if (error) {
-            logger.error({ error, vacationId }, 'Failed to delete vacation');
-            throw new Error('Failed to delete vacation');
-        }
-        logger.info({ vacationId }, 'Vacation deleted');
-    }
-    // ─── Scheduler Settings ─────────────────────────────────────
-    /**
-     * Get scheduler settings for an owner.
-     */
-    async getSettings(db, ownerId) {
-        const { data, error } = await db
-            .from('planner_scheduler_settings')
-            .select('*')
-            .eq('owner_id', ownerId)
-            .maybeSingle();
-        if (error) {
-            logger.error({ error, ownerId }, 'Failed to get scheduler settings');
-            throw new Error('Failed to retrieve settings');
-        }
-        const defaults = this.config.defaults || {};
-        if (!data) {
-            return {
-                eventName: 'Session',
-                zoomLink: null,
-                description: null,
-                sessionDurationMinutes: defaults.sessionDurationMinutes ?? 60,
-                maxDaysAhead: defaults.maxDaysAhead ?? 14,
-                minLeadTimeHours: defaults.minLeadTimeHours ?? 24,
-                timeIncrementMinutes: defaults.timeIncrementMinutes ?? 15,
-                bufferBeforeMinutes: 0,
-                bufferAfterMinutes: 0,
-                maxSessionsPerDay: null,
-                maxSessionsPerWeek: null,
-            };
-        }
-        return {
-            eventName: data.event_name ?? 'Session',
-            zoomLink: data.zoom_link ?? null,
-            description: data.description ?? null,
-            sessionDurationMinutes: data.session_duration_minutes ?? defaults.sessionDurationMinutes ?? 60,
-            maxDaysAhead: data.max_days_ahead ?? defaults.maxDaysAhead ?? 14,
-            minLeadTimeHours: data.min_lead_time_hours ?? defaults.minLeadTimeHours ?? 24,
-            timeIncrementMinutes: data.time_increment_minutes ?? defaults.timeIncrementMinutes ?? 15,
-            bufferBeforeMinutes: data.buffer_before_minutes ?? 0,
-            bufferAfterMinutes: data.buffer_after_minutes ?? 0,
-            maxSessionsPerDay: data.max_sessions_per_day ?? null,
-            maxSessionsPerWeek: data.max_sessions_per_week ?? null,
-        };
-    }
-    /**
-     * Upsert scheduler settings for an owner.
-     */
-    async updateSettings(db, ownerId, organizationId, settings) {
-        const row = {
-            owner_id: ownerId,
-            organization_id: organizationId,
-            updated_at: new Date().toISOString(),
-        };
-        if (settings.eventName !== undefined)
-            row.event_name = settings.eventName;
-        if (settings.zoomLink !== undefined)
-            row.zoom_link = settings.zoomLink;
-        if (settings.description !== undefined)
-            row.description = settings.description;
-        if (settings.sessionDurationMinutes !== undefined)
-            row.session_duration_minutes = settings.sessionDurationMinutes;
-        if (settings.maxDaysAhead !== undefined)
-            row.max_days_ahead = settings.maxDaysAhead;
-        if (settings.minLeadTimeHours !== undefined)
-            row.min_lead_time_hours = settings.minLeadTimeHours;
-        if (settings.timeIncrementMinutes !== undefined)
-            row.time_increment_minutes = settings.timeIncrementMinutes;
-        if (settings.bufferBeforeMinutes !== undefined)
-            row.buffer_before_minutes = settings.bufferBeforeMinutes;
-        if (settings.bufferAfterMinutes !== undefined)
-            row.buffer_after_minutes = settings.bufferAfterMinutes;
-        if (settings.maxSessionsPerDay !== undefined)
-            row.max_sessions_per_day = settings.maxSessionsPerDay;
-        if (settings.maxSessionsPerWeek !== undefined)
-            row.max_sessions_per_week = settings.maxSessionsPerWeek;
-        const { data, error } = await db
-            .from('planner_scheduler_settings')
-            .upsert(row, { onConflict: 'owner_id' })
-            .select()
-            .single();
-        if (error) {
-            logger.error({ error, ownerId }, 'Failed to update scheduler settings');
-            throw new Error('Failed to save settings');
-        }
-        logger.info({ ownerId }, 'Scheduler settings updated');
-        return data;
-    }
-    // ─── Available Slots ────────────────────────────────────────
-    /**
-     * Compute available booking slots for a specific date.
-     * Checks: availability, vacations, existing appointments, booking window, lead time.
-     */
-    async getAvailableSlots(db, ownerId, date) {
-        const parsedDate = new Date(date + 'T00:00:00Z');
-        if (isNaN(parsedDate.getTime())) {
-            throw new Error('Invalid date');
-        }
-        const dayOfWeek = parsedDate.getUTCDay();
-        // 1. Check vacation
-        const onVacation = await this.isOnVacation(db, ownerId, date);
-        const settings = await this.getSettings(db, ownerId);
-        if (onVacation) {
-            return { date, dayOfWeek, ownerId, slots: [], sessionDurationMinutes: settings.sessionDurationMinutes };
-        }
-        // 2. Check booking window
-        const now = new Date();
-        const requestedDate = new Date(date + 'T23:59:59Z');
-        const maxDate = new Date(now);
-        maxDate.setDate(maxDate.getDate() + settings.maxDaysAhead);
-        if (requestedDate > maxDate) {
-            return { date, dayOfWeek, ownerId, slots: [], sessionDurationMinutes: settings.sessionDurationMinutes };
-        }
-        // 3. Get availability for this day of week
-        const { data: availabilitySlots, error: availError } = await db
-            .from('planner_availability_slots')
-            .select('*')
-            .eq('owner_id', ownerId)
-            .eq('day_of_week', dayOfWeek)
-            .eq('is_available', true)
-            .order('start_time', { ascending: true });
-        if (availError || !availabilitySlots?.length) {
-            return { date, dayOfWeek, ownerId, slots: [], sessionDurationMinutes: settings.sessionDurationMinutes };
-        }
-        // 4. Get existing appointments for this date
-        const existingAppointments = await this.getExistingAppointments(db, ownerId, date);
-        // 4b. Get external busy slots (e.g. Google Calendar) — bidirectional sync
-        if (this.config.getExternalBusySlots) {
-            try {
-                const externalBusy = await this.config.getExternalBusySlots(ownerId, date);
-                if (externalBusy.length > 0) {
-                    const existingTimes = new Set(existingAppointments.map((a) => `${a.start_time}|${a.end_time}`));
-                    for (const busy of externalBusy) {
-                        const key = `${busy.start_time}|${busy.end_time}`;
-                        if (!existingTimes.has(key)) {
-                            existingAppointments.push(busy);
-                            existingTimes.add(key);
-                        }
-                    }
-                    logger.debug({ ownerId, date, externalCount: externalBusy.length }, 'External busy slots merged');
-                }
-            }
-            catch (err) {
-                logger.warn({ error: err, ownerId, date }, 'Failed to fetch external busy slots (continuing without)');
-            }
-        }
-        // 5. Compute slots
-        const allSlots = computeAvailableSlots(availabilitySlots, existingAppointments, date, settings.sessionDurationMinutes);
-        // 6. Filter by minimum lead time
-        const minBookingTime = new Date(now.getTime() + settings.minLeadTimeHours * 60 * 60 * 1000);
-        const slots = allSlots.filter((slot) => {
-            const slotStart = new Date(`${date}T${slot.startTime}:00Z`);
-            return slotStart >= minBookingTime;
-        });
-        return { date, dayOfWeek, ownerId, slots, sessionDurationMinutes: settings.sessionDurationMinutes };
-    }
-    /**
-     * Get existing scheduled appointments for an owner on a date.
-     */
-    async getExistingAppointments(db, ownerId, date) {
-        const dayStart = `${date}T00:00:00Z`;
-        const dayEnd = `${date}T23:59:59Z`;
-        const appointments = [];
-        // Appointments where owner is organizer
-        const { data: organizerAppts } = await db
-            .from('planner_appointments')
-            .select('start_time, end_time')
-            .eq('organizer_id', ownerId)
-            .eq('status', 'scheduled')
-            .gte('start_time', dayStart)
-            .lte('start_time', dayEnd);
-        if (organizerAppts) {
-            appointments.push(...organizerAppts);
-        }
-        // If parent resource is configured, also check appointments through parent records
-        if (this.config.parentResource) {
-            const { table, foreignKey } = this.config.parentResource;
-            const { data: ownerParents } = await db
-                .from(table)
-                .select('id')
-                .or(`${foreignKey}.eq.${ownerId}`);
-            const parentIds = (ownerParents || []).map((p) => p.id);
-            if (parentIds.length > 0) {
-                const { data: parentAppts } = await db
-                    .from('planner_appointments')
-                    .select('start_time, end_time')
-                    .in('parent_id', parentIds)
-                    .eq('status', 'scheduled')
-                    .gte('start_time', dayStart)
-                    .lte('start_time', dayEnd);
-                if (parentAppts) {
-                    // Deduplicate
-                    const existingTimes = new Set(appointments.map((a) => `${a.start_time}|${a.end_time}`));
-                    for (const appt of parentAppts) {
-                        const key = `${appt.start_time}|${appt.end_time}`;
-                        if (!existingTimes.has(key)) {
-                            appointments.push(appt);
-                            existingTimes.add(key);
-                        }
-                    }
-                }
-            }
-        }
-        return appointments;
-    }
-    // ─── Team Availability ──────────────────────────────────────
-    /**
-     * Get availability for all owners in an organization for a specific date.
-     */
-    async getTeamAvailability(db, organizationId, date) {
-        const parsedDate = new Date(date + 'T00:00:00Z');
-        if (isNaN(parsedDate.getTime())) {
-            throw new Error('Invalid date');
-        }
-        const dayOfWeek = parsedDate.getUTCDay();
-        const ownerTable = this.ownerTable;
-        const orgColumn = this.config.ownerOrgColumn || 'active_organization_id';
-        // Get all owners (coaches/consultants) in this organization
-        const roles = this.ownerRoles;
-        let ownerQuery = db
-            .from(ownerTable)
-            .select('id, name, avatar_url')
-            .eq(orgColumn, organizationId);
-        if (roles.length === 1) {
-            ownerQuery = ownerQuery.eq('role', roles[0]);
-        }
-        else {
-            ownerQuery = ownerQuery.in('role', roles);
-        }
-        const { data: owners, error: ownersError } = await ownerQuery;
-        if (ownersError || !owners?.length) {
-            return { date, dayOfWeek, owners: [] };
-        }
-        // For each owner, compute their availability
-        const ownerResults = await Promise.all(owners.map(async (owner) => {
-            try {
-                const dayAvailability = await this.getAvailableSlots(db, owner.id, date);
-                const onVacation = await this.isOnVacation(db, owner.id, date);
-                return {
-                    id: owner.id,
-                    name: owner.name,
-                    avatarUrl: owner.avatar_url,
-                    slots: dayAvailability.slots,
-                    vacationDay: onVacation,
-                };
-            }
-            catch {
-                return {
-                    id: owner.id,
-                    name: owner.name,
-                    avatarUrl: owner.avatar_url,
-                    slots: [],
-                    vacationDay: false,
-                };
-            }
-        }));
-        return { date, dayOfWeek, owners: ownerResults };
-    }
-    // ─── Appointments ───────────────────────────────────────────
-    /**
-     * List all appointments in the organization (for team/admin views).
-     */
-    async listTeamAppointments(db, organizationId, options) {
-        let query = db
-            .from('planner_appointments')
-            .select('*')
-            .eq('organization_id', organizationId)
-            .order('start_time', { ascending: true });
-        if (options?.status === 'all') {
-            // No filter
-        }
-        else if (options?.status && this.appointmentStatuses.includes(options.status)) {
-            query = query.eq('status', options.status);
-        }
-        else {
-            query = query.neq('status', 'cancelled');
-        }
-        if (options?.dateFrom) {
-            query = query.gte('start_time', `${options.dateFrom}T00:00:00Z`);
-        }
-        if (options?.dateTo) {
-            query = query.lte('start_time', `${options.dateTo}T23:59:59Z`);
-        }
-        const { data, error } = await query;
-        if (error) {
-            logger.error({ error, organizationId }, 'Failed to list team appointments');
-            throw new Error('Failed to retrieve team appointments');
-        }
-        return (data || []).map((row) => transformAppointment(row, this.config));
-    }
-    /**
-     * List all appointments for a user (as organizer or via parent resources).
-     */
-    async listAppointments(db, userId, options) {
-        let query = db
-            .from('planner_appointments')
-            .select('*')
-            .order('start_time', { ascending: true });
-        // Build OR filter: organizer OR involved via parent resource
-        if (this.config.parentResource) {
-            const { table, foreignKey, clientKey } = this.config.parentResource;
-            // Find parent IDs where user is owner or client
-            const orParts = [`${foreignKey}.eq.${userId}`];
-            if (clientKey)
-                orParts.push(`${clientKey}.eq.${userId}`);
-            const { data: userParents } = await db
-                .from(table)
-                .select('id')
-                .or(orParts.join(','));
-            const parentIds = (userParents || []).map((p) => p.id);
-            if (parentIds.length > 0) {
-                query = query.or(`organizer_id.eq.${userId},parent_id.in.(${parentIds.join(',')})`);
-            }
-            else {
-                query = query.eq('organizer_id', userId);
-            }
-        }
-        else {
-            query = query.eq('organizer_id', userId);
-        }
-        if (options?.status === 'all') {
-            // No filter
-        }
-        else if (options?.status && this.appointmentStatuses.includes(options.status)) {
-            query = query.eq('status', options.status);
-        }
-        else {
-            query = query.neq('status', 'cancelled');
-        }
-        const { data, error } = await query;
-        if (error) {
-            logger.error({ error, userId }, 'Failed to list appointments');
-            throw new Error('Failed to retrieve appointments');
-        }
-        return (data || []).map((row) => transformAppointment(row, this.config));
-    }
-    /**
-     * Create an appointment.
-     */
-    async createAppointment(db, organizerId, organizationId, input) {
-        const start = new Date(input.startTime);
-        const end = new Date(input.endTime);
-        if (isNaN(start.getTime()) || isNaN(end.getTime())) {
-            throw new Error('Invalid date format for startTime or endTime');
-        }
-        if (end <= start) {
-            throw new Error('endTime must be after startTime');
-        }
-        const appointmentType = input.type || 'online';
-        if (!this.appointmentTypes.includes(appointmentType)) {
-            throw new Error(`Invalid type. Must be one of: ${this.appointmentTypes.join(', ')}`);
-        }
-        const insertData = {
-            organization_id: organizationId,
-            organizer_id: organizerId,
-            title: input.title,
-            start_time: start.toISOString(),
-            end_time: end.toISOString(),
-            type: appointmentType,
-            status: 'scheduled',
-        };
-        if (input.parentId)
-            insertData.parent_id = input.parentId;
-        if (input.description !== undefined)
-            insertData.description = input.description;
-        if (input.location !== undefined)
-            insertData.location = input.location;
-        if (Array.isArray(input.attendeeIds))
-            insertData.attendee_ids = input.attendeeIds;
-        const { data, error } = await db
-            .from('planner_appointments')
-            .insert(insertData)
-            .select()
-            .single();
-        if (error) {
-            logger.error({ error, organizerId }, 'Failed to create appointment');
-            if (error.code === '23503') {
-                throw new Error('Invalid parent resource ID');
-            }
-            throw new Error('Failed to create appointment');
-        }
-        logger.info({ appointmentId: data.id, organizerId }, 'Appointment created');
-        const appointment = transformAppointment(data, this.config);
-        // Fire callback (non-blocking)
-        if (this.config.onAppointmentCreated) {
-            const ctx = { ownerId: organizerId, organizationId };
-            this.config.onAppointmentCreated(appointment, ctx).catch((err) => {
-                logger.error({ error: err, appointmentId: data.id }, 'onAppointmentCreated callback failed');
-            });
-        }
-        return appointment;
-    }
-    /**
-     * Update an appointment.
-     */
-    async updateAppointment(db, appointmentId, updates) {
-        const updateData = {
-            updated_at: new Date().toISOString(),
-        };
-        if (updates.title !== undefined)
-            updateData.title = updates.title;
-        if (updates.description !== undefined)
-            updateData.description = updates.description;
-        if (updates.location !== undefined)
-            updateData.location = updates.location;
-        if (updates.startTime !== undefined) {
-            const start = new Date(updates.startTime);
-            if (isNaN(start.getTime()))
-                throw new Error('Invalid startTime');
-            updateData.start_time = start.toISOString();
-        }
-        if (updates.endTime !== undefined) {
-            const end = new Date(updates.endTime);
-            if (isNaN(end.getTime()))
-                throw new Error('Invalid endTime');
-            updateData.end_time = end.toISOString();
-        }
-        if (updates.type !== undefined) {
-            if (!this.appointmentTypes.includes(updates.type)) {
-                throw new Error(`Invalid type. Must be one of: ${this.appointmentTypes.join(', ')}`);
-            }
-            updateData.type = updates.type;
-        }
-        if (updateData.start_time && updateData.end_time) {
-            if (new Date(updateData.end_time) <= new Date(updateData.start_time)) {
-                throw new Error('endTime must be after startTime');
-            }
-        }
-        const { data, error } = await db
-            .from('planner_appointments')
-            .update(updateData)
-            .eq('id', appointmentId)
-            .select()
-            .single();
-        if (error) {
-            if (error.code === 'PGRST116')
-                throw new Error('Appointment not found');
-            logger.error({ error, appointmentId }, 'Failed to update appointment');
-            throw new Error('Failed to update appointment');
-        }
-        logger.info({ appointmentId }, 'Appointment updated');
-        return transformAppointment(data, this.config);
-    }
-    /**
-     * Cancel an appointment (soft delete).
-     */
-    async cancelAppointment(db, appointmentId, organizationId) {
-        const { data, error } = await db
-            .from('planner_appointments')
-            .update({ status: 'cancelled', updated_at: new Date().toISOString() })
-            .eq('id', appointmentId)
-            .neq('status', 'cancelled')
-            .select()
-            .single();
-        if (error) {
-            if (error.code === 'PGRST116')
-                throw new Error('Appointment not found');
-            logger.error({ error, appointmentId }, 'Failed to cancel appointment');
-            throw new Error('Failed to cancel appointment');
-        }
-        logger.info({ appointmentId }, 'Appointment cancelled');
-        const appointment = transformAppointment(data, this.config);
-        if (this.config.onAppointmentCancelled) {
-            const ctx = { ownerId: data.organizer_id, organizationId };
-            this.config.onAppointmentCancelled(appointment, ctx).catch((err) => {
-                logger.error({ error: err, appointmentId }, 'onAppointmentCancelled callback failed');
-            });
-        }
-        return appointment;
-    }
-    /**
-     * Complete an appointment.
-     */
-    async completeAppointment(db, appointmentId, organizationId) {
-        const { data, error } = await db
-            .from('planner_appointments')
-            .update({ status: 'completed', updated_at: new Date().toISOString() })
-            .eq('id', appointmentId)
-            .eq('status', 'scheduled')
-            .select()
-            .single();
-        if (error) {
-            if (error.code === 'PGRST116')
-                throw new Error('Appointment not found');
-            logger.error({ error, appointmentId }, 'Failed to complete appointment');
-            throw new Error('Failed to complete appointment');
-        }
-        logger.info({ appointmentId }, 'Appointment completed');
-        const appointment = transformAppointment(data, this.config);
-        if (this.config.onAppointmentCompleted) {
-            const ctx = { ownerId: data.organizer_id, organizationId };
-            this.config.onAppointmentCompleted(appointment, ctx).catch((err) => {
-                logger.error({ error: err, appointmentId }, 'onAppointmentCompleted callback failed');
-            });
-        }
-        return appointment;
-    }
-    // ─── Public Booking ─────────────────────────────────────────
-    /**
-     * Get public scheduler page data (no auth).
-     */
-    async getPublicSchedulerData(db, ownerId) {
-        const ownerTable = this.ownerTable;
-        const orgColumn = this.config.ownerOrgColumn || 'active_organization_id';
-        const { data: ownerRow, error: ownerError } = await db
-            .from(ownerTable)
-            .select('*')
-            .eq('id', ownerId)
-            .single();
-        if (ownerError || !ownerRow)
-            return null;
-        const owner = ownerRow;
-        const orgId = owner[orgColumn];
-        const { data: org } = await db
-            .from('organizations')
-            .select('name')
-            .eq('id', orgId)
-            .single();
-        const settings = await this.getSettings(db, ownerId);
-        const { data: availability } = await db
-            .from('planner_availability_slots')
-            .select('day_of_week')
-            .eq('owner_id', ownerId)
-            .eq('is_available', true);
-        const availableDays = [...new Set((availability || []).map((s) => s.day_of_week))];
-        return {
-            owner: { id: owner.id, name: owner.name, avatarUrl: owner.avatar_url },
-            organization: { name: org?.name ?? null },
-            settings,
-            availableDays,
-        };
-    }
-    /**
-     * Book a slot via public booking (no auth).
-     */
-    async publicBook(db, ownerId, input) {
-        // Validate
-        if (!input.name || !input.email || !input.date || !input.startTime || !input.endTime) {
-            throw new Error('name, email, date, startTime, and endTime are required');
-        }
-        const parsedDate = new Date(input.date + 'T00:00:00Z');
-        if (isNaN(parsedDate.getTime()))
-            throw new Error('Invalid date');
-        if (timeToMinutes(input.startTime) >= timeToMinutes(input.endTime)) {
-            throw new Error('endTime must be after startTime');
-        }
-        // Check vacation
-        const onVacation = await this.isOnVacation(db, ownerId, input.date);
-        if (onVacation) {
-            throw new Error('Owner is on vacation on this date');
-        }
-        // Check availability
-        const dayOfWeek = parsedDate.getUTCDay();
-        const { data: availSlots } = await db
-            .from('planner_availability_slots')
-            .select('*')
-            .eq('owner_id', ownerId)
-            .eq('day_of_week', dayOfWeek)
-            .eq('is_available', true);
-        const requestedStart = timeToMinutes(input.startTime);
-        const requestedEnd = timeToMinutes(input.endTime);
-        const isWithin = (availSlots || []).some((slot) => {
-            const slotStart = timeToMinutes(slot.start_time);
-            const slotEnd = timeToMinutes(slot.end_time);
-            return requestedStart >= slotStart && requestedEnd <= slotEnd;
-        });
-        if (!isWithin) {
-            throw new Error('Requested time is outside availability');
-        }
-        // Check conflicts
-        const existingAppts = await this.getExistingAppointments(db, ownerId, input.date);
-        const hasConflict = existingAppts.some((appt) => {
-            const apptStart = timeToMinutes(appt.start_time.substring(11, 16));
-            const apptEnd = timeToMinutes(appt.end_time.substring(11, 16));
-            return requestedStart < apptEnd && requestedEnd > apptStart;
-        });
-        if (hasConflict) {
-            throw new Error('Time slot is no longer available');
-        }
-        // Get owner info
-        const ownerTable = this.ownerTable;
-        const orgColumn = this.config.ownerOrgColumn || 'active_organization_id';
-        const { data: ownerData } = await db
-            .from(ownerTable)
-            .select(`id, name, ${orgColumn}`)
-            .eq('id', ownerId)
-            .single();
-        if (!ownerData)
-            throw new Error('Owner not found');
-        const organizationId = ownerData[orgColumn];
-        const settings = await this.getSettings(db, ownerId);
-        const zoomLink = settings.zoomLink;
-        // Auto-link to parent resource if booker email matches
-        let parentId = null;
-        if (this.config.parentResource) {
-            const { table, foreignKey, clientKey } = this.config.parentResource;
-            if (clientKey) {
-                const { data: bookerUser } = await db
-                    .from(ownerTable)
-                    .select('id')
-                    .eq('email', input.email.toLowerCase().trim())
-                    .eq(orgColumn, organizationId)
-                    .maybeSingle();
-                if (bookerUser) {
-                    const { data: matchingParent } = await db
-                        .from(table)
-                        .select('id')
-                        .or(`${foreignKey}.eq.${ownerId}`)
-                        .eq(clientKey, bookerUser.id)
-                        .eq('status', 'active')
-                        .limit(1)
-                        .maybeSingle();
-                    if (matchingParent) {
-                        parentId = matchingParent.id;
-                        logger.info({ parentId, bookerEmail: input.email, ownerId }, 'Auto-linked public booking to parent');
-                    }
-                }
-            }
-        }
-        const startISO = `${input.date}T${input.startTime.length === 5 ? input.startTime + ':00' : input.startTime}Z`;
-        const endISO = `${input.date}T${input.endTime.length === 5 ? input.endTime + ':00' : input.endTime}Z`;
-        const { data: appointment, error: insertError } = await db
-            .from('planner_appointments')
-            .insert({
-            organization_id: organizationId,
-            parent_id: parentId,
-            organizer_id: ownerId,
-            title: `${settings.eventName} - ${input.name}`,
-            description: [
-                'Booked via public scheduler',
-                `Name: ${input.name}`,
-                `Email: ${input.email}`,
-                input.notes ? `Notes: ${input.notes}` : null,
-                zoomLink ? `Zoom: ${zoomLink}` : null,
-            ].filter(Boolean).join('\n'),
-            start_time: startISO,
-            end_time: endISO,
-            type: 'online',
-            status: 'scheduled',
-        })
-            .select()
-            .single();
-        if (insertError) {
-            logger.error({ error: insertError, ownerId, name: input.name }, 'Failed to create public booking');
-            throw new Error('Failed to create appointment');
-        }
-        logger.info({
-            appointmentId: appointment.id,
-            ownerId,
-            visitorName: input.name,
-            visitorEmail: input.email,
-        }, 'Public booking created');
-        const record = transformAppointment(appointment, this.config);
-        // Fire callback
-        if (this.config.onPublicBooking) {
-            const ctx = { ownerId, organizationId };
-            const visitor = { name: input.name, email: input.email, notes: input.notes };
-            this.config.onPublicBooking(record, visitor, ctx).catch((err) => {
-                logger.error({ error: err, appointmentId: appointment.id }, 'onPublicBooking callback failed');
-            });
-        }
-        return record;
-    }
-    // ─── Computed Availability (Phase 2) ─────────────────────────
-    /**
-     * Compute truly available booking windows for an owner across a date range.
-     *
-     * Formula:
-     *   available = scheduleWindows
-     *     − googleCalendarBusy (all selected calendars)
-     *     − internalAppointments ± buffer
-     *     − activeReservations
-     *     − vacations
-     *     − minLeadTimeWindow (now → now + minLeadTimeHours)
-     *     − futureLimit (now + maxDaysAhead → ∞)
-     *
-     * Returns continuous free windows AND discrete bookable slots.
-     */
-    async getComputedAvailability(db, ownerId, dateFrom, dateTo) {
-        if (!/^\d{4}-\d{2}-\d{2}$/.test(dateFrom) || !/^\d{4}-\d{2}-\d{2}$/.test(dateTo)) {
-            throw new Error('dateFrom and dateTo must be YYYY-MM-DD');
-        }
-        if (dateFrom > dateTo) {
-            throw new Error('dateFrom must be on or before dateTo');
-        }
-        const settings = await this.getSettings(db, ownerId);
-        // 1. Schedule windows from recurring availability slots
-        const { data: rawSlots } = await db
-            .from('planner_availability_slots')
-            .select('day_of_week, start_time, end_time, is_available')
-            .eq('owner_id', ownerId)
-            .eq('is_available', true);
-        const scheduleWindows = buildScheduleIntervals((rawSlots || []).map((s) => ({
-            dayOfWeek: s.day_of_week,
-            startTime: typeof s.start_time === 'string' ? s.start_time.substring(0, 5) : s.start_time,
-            endTime: typeof s.end_time === 'string' ? s.end_time.substring(0, 5) : s.end_time,
-            isAvailable: s.is_available,
-        })), dateFrom, dateTo);
-        // 2. Internal appointments (with buffer)
-        const dayStart = `${dateFrom}T00:00:00Z`;
-        const dayEnd = `${dateTo}T23:59:59Z`;
-        const { data: internalAppts } = await db
-            .from('planner_appointments')
-            .select('start_time, end_time')
-            .eq('organizer_id', ownerId)
-            .eq('status', 'scheduled')
-            .gte('start_time', dayStart)
-            .lte('start_time', dayEnd);
-        const bufferBeforeMs = (settings.bufferBeforeMinutes || 0) * 60 * 1000;
-        const bufferAfterMs = (settings.bufferAfterMinutes || 0) * 60 * 1000;
-        const appointmentBusy = buildAppointmentIntervals(internalAppts || [], bufferBeforeMs, bufferAfterMs);
-        // 3. Active slot reservations (anti-double-book)
-        const nowIso = new Date().toISOString();
-        const ownerCol = await this.detectReservedSlotsOwnerColumn(db);
-        const { data: reservations } = await db
-            .from('planner_reserved_slots')
-            .select('slot_start, slot_end, release_at')
-            .eq(ownerCol, ownerId)
-            .gte('slot_end', dayStart)
-            .lte('slot_start', dayEnd)
-            .gt('release_at', nowIso);
-        const reservationBusy = (reservations || []).map((r) => ({
-            start: new Date(r.slot_start).getTime(),
-            end: new Date(r.slot_end).getTime(),
-        }));
-        // 4. Vacations
-        const { data: vacations } = await db
-            .from('planner_vacations')
-            .select('start_date, end_date')
-            .eq('owner_id', ownerId)
-            .lte('start_date', dateTo)
-            .gte('end_date', dateFrom);
-        const vacationBusy = buildVacationIntervals(vacations || [], dateFrom, dateTo);
-        // 5. External (Google Calendar) busy slots — pass full range
-        let externalBusy = [];
-        if (this.config.getExternalBusySlots) {
-            try {
-                const slots = await this.config.getExternalBusySlots(ownerId, dateFrom, dateTo);
-                externalBusy = (slots || []).map((s) => ({
-                    start: new Date(s.start_time).getTime(),
-                    end: new Date(s.end_time).getTime(),
-                }));
-            }
-            catch (err) {
-                logger.warn({ error: err, ownerId, dateFrom, dateTo }, 'Failed to fetch external busy (continuing)');
-            }
-        }
-        // 6. Min lead time + future booking horizon — clip the schedule
-        const now = Date.now();
-        const minBookingMs = now + (settings.minLeadTimeHours || 0) * 60 * 60 * 1000;
-        const maxBookingDate = new Date(now + (settings.maxDaysAhead || 14) * 24 * 60 * 60 * 1000);
-        const maxBookingMs = maxBookingDate.getTime();
-        const clippedSchedule = scheduleWindows
-            .map((w) => ({
-            start: Math.max(w.start, minBookingMs),
-            end: Math.min(w.end, maxBookingMs),
-        }))
-            .filter((w) => w.end > w.start);
-        // 7. Subtract everything
-        const allBusy = unionIntervals([...appointmentBusy, ...reservationBusy, ...vacationBusy, ...externalBusy]);
-        const freeWindows = subtractIntervals(unionIntervals(clippedSchedule), allBusy);
-        // 8. Discrete bookable slots
-        const sessionMs = (settings.sessionDurationMinutes || 60) * 60 * 1000;
-        const incrementMs = (settings.timeIncrementMinutes || 15) * 60 * 1000;
-        const slotIntervals = splitIntoSlots(freeWindows, sessionMs, incrementMs);
-        // 9. Apply max sessions per day / week limits
-        let limitedSlots = slotIntervals;
-        if (settings.maxSessionsPerDay || settings.maxSessionsPerWeek) {
-            const dayCount = new Map();
-            const weekCount = new Map();
-            // Count existing appointments per day/week to know baseline
-            for (const a of internalAppts || []) {
-                const d = a.start_time.substring(0, 10);
-                dayCount.set(d, (dayCount.get(d) || 0) + 1);
-                const wk = isoWeekKey(new Date(a.start_time));
-                weekCount.set(wk, (weekCount.get(wk) || 0) + 1);
-            }
-            const dayLimit = settings.maxSessionsPerDay ?? Infinity;
-            const weekLimit = settings.maxSessionsPerWeek ?? Infinity;
-            limitedSlots = slotIntervals.filter((slot) => {
-                const slotDate = new Date(slot.start);
-                const dayKey = slotDate.toISOString().substring(0, 10);
-                const weekKey = isoWeekKey(slotDate);
-                const dCount = dayCount.get(dayKey) || 0;
-                const wCount = weekCount.get(weekKey) || 0;
-                if (dCount >= dayLimit)
-                    return false;
-                if (wCount >= weekLimit)
-                    return false;
-                // Reserve a slot in the count map so subsequent slots in same day/week
-                // also count toward the limit even though they're not booked yet —
-                // ensures we never SHOW more slots than the user can book.
-                return true;
-            });
-        }
-        return {
-            ownerId,
-            dateFrom,
-            dateTo,
-            windows: intervalsToSlots(freeWindows),
-            slots: intervalsToSlots(limitedSlots),
-            busySources: {
-                appointments: appointmentBusy.length,
-                externalCalendars: externalBusy.length,
-                reservations: reservationBusy.length,
-                vacations: vacationBusy.length,
-            },
-        };
-    }
-    // ─── Slot Reservations (Phase 3) ─────────────────────────────
-    /**
-     * Temporarily reserve a slot for `ttlSeconds` seconds.
-     * Throws if another active reservation already covers the slot.
-     */
-    async reserveSlot(db, ownerId, organizationId, slotStart, slotEnd, ttlSeconds = 300) {
-        if (new Date(slotStart) >= new Date(slotEnd)) {
-            throw new Error('slotEnd must be after slotStart');
-        }
-        const releaseAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
-        const bookingUid = `${ownerId}-${slotStart}-${Math.random().toString(36).slice(2, 10)}`;
-        // Detect column name once: legacy schemas use coach_id, new use owner_id
-        const ownerColumn = await this.detectReservedSlotsOwnerColumn(db);
-        // First clean any expired reservations on this exact slot to allow re-claim
-        await db
-            .from('planner_reserved_slots')
-            .delete()
-            .eq(ownerColumn, ownerId)
-            .eq('slot_start', slotStart)
-            .eq('slot_end', slotEnd)
-            .lt('release_at', new Date().toISOString());
-        const insertRow = {
-            organization_id: organizationId,
-            slot_start: slotStart,
-            slot_end: slotEnd,
-            booking_uid: bookingUid,
-            release_at: releaseAt,
-        };
-        insertRow[ownerColumn] = ownerId;
-        const { data, error } = await db
-            .from('planner_reserved_slots')
-            .insert(insertRow)
-            .select()
-            .single();
-        if (error) {
-            if (error.code === '23505') {
-                throw new Error('Slot is already reserved');
-            }
-            logger.error({ error, ownerId, slotStart }, 'Failed to reserve slot');
-            throw new Error('Failed to reserve slot');
-        }
-        return {
-            id: data.id,
-            organizationId: data.organization_id,
-            ownerId: data.owner_id ?? data.coach_id,
-            slotStart: data.slot_start,
-            slotEnd: data.slot_end,
-            bookingUid: data.booking_uid,
-            releaseAt: data.release_at,
-            createdAt: data.created_at,
-        };
-    }
-    _reservedSlotsOwnerColumn = null;
-    async detectReservedSlotsOwnerColumn(db) {
-        if (this._reservedSlotsOwnerColumn)
-            return this._reservedSlotsOwnerColumn;
-        // Try owner_id first
-        const tryOwner = await db.from('planner_reserved_slots').select('owner_id').limit(0);
-        if (!tryOwner.error) {
-            this._reservedSlotsOwnerColumn = 'owner_id';
-            return 'owner_id';
-        }
-        // Fallback to coach_id (legacy CoachHub schema)
-        this._reservedSlotsOwnerColumn = 'coach_id';
-        return 'coach_id';
-    }
-    async releaseSlot(db, reservationId) {
-        const { error } = await db.from('planner_reserved_slots').delete().eq('id', reservationId);
-        if (error) {
-            logger.error({ error, reservationId }, 'Failed to release slot');
-            throw new Error('Failed to release slot');
-        }
-    }
-    /**
-     * Delete reservations whose release_at is in the past. Run via cron.
-     * Returns number of cleaned reservations.
-     */
-    async cleanupExpiredReservations(db) {
-        const { data, error } = await db
-            .from('planner_reserved_slots')
-            .delete()
-            .lt('release_at', new Date().toISOString())
-            .select('id');
-        if (error) {
-            logger.error({ error }, 'Cleanup expired reservations failed');
-            return 0;
-        }
-        const count = data?.length || 0;
-        if (count > 0)
-            logger.info({ count }, 'Cleaned expired reservations');
-        return count;
-    }
-    // ─── Coach Auto-Assignment (Phase 3) ─────────────────────────
-    /**
-     * Get all coaches in an organization with their assignment configuration
-     * and current active-track count.
-     */
-    async getCoachAssignmentConfig(db, organizationId) {
-        const ownerTable = this.ownerTable;
-        const orgColumn = this.config.ownerOrgColumn || 'active_organization_id';
-        const roles = this.ownerRoles;
-        let coachQuery = db
-            .from(ownerTable)
-            .select('id, name, email, avatar_url')
-            .eq(orgColumn, organizationId);
-        coachQuery = roles.length === 1 ? coachQuery.eq('role', roles[0]) : coachQuery.in('role', roles);
-        const { data: coaches } = await coachQuery;
-        if (!coaches?.length)
-            return [];
-        const { data: configs } = await db
-            .from('planner_coach_assignment_config')
-            .select('*')
-            .eq('organization_id', organizationId);
-        const configMap = new Map((configs || []).map((c) => [c.coach_id, c]));
-        // Active track counts (only if a parent resource is configured)
-        let trackCounts = new Map();
-        if (this.config.parentResource) {
-            const { table, foreignKey } = this.config.parentResource;
-            const { data: tracks } = await db
-                .from(table)
-                .select(`${foreignKey}`)
-                .eq('status', 'active');
-            for (const t of tracks || []) {
-                const cid = t[foreignKey];
-                if (cid)
-                    trackCounts.set(cid, (trackCounts.get(cid) || 0) + 1);
-            }
-        }
-        return coaches.map((c) => {
-            const cfg = configMap.get(c.id);
-            return {
-                coachId: c.id,
-                name: c.name,
-                email: c.email,
-                avatarUrl: c.avatar_url,
-                priority: cfg?.priority ?? 2,
-                weight: cfg?.weight ?? 100,
-                maxActiveTracks: cfg?.max_active_tracks ?? null,
-                isAvailableForAssignment: cfg?.is_available_for_assignment ?? true,
-                activeTracks: trackCounts.get(c.id) || 0,
-                lastAssignedAt: cfg?.last_assigned_at ?? null,
-            };
-        });
-    }
-    /**
-     * Upsert assignment config for one coach.
-     */
-    async updateCoachAssignmentConfig(db, organizationId, coachId, updates) {
-        const row = {
-            organization_id: organizationId,
-            coach_id: coachId,
-            updated_at: new Date().toISOString(),
-        };
-        if (updates.priority !== undefined)
-            row.priority = updates.priority;
-        if (updates.weight !== undefined)
-            row.weight = updates.weight;
-        if (updates.maxActiveTracks !== undefined)
-            row.max_active_tracks = updates.maxActiveTracks;
-        if (updates.isAvailableForAssignment !== undefined)
-            row.is_available_for_assignment = updates.isAvailableForAssignment;
-        const { error } = await db
-            .from('planner_coach_assignment_config')
-            .upsert(row, { onConflict: 'organization_id,coach_id' });
-        if (error) {
-            logger.error({ error, organizationId, coachId }, 'Failed to update coach assignment config');
-            throw new Error('Failed to update assignment config');
-        }
-    }
-    /**
-     * Cal.com-inspired 3-layer auto-assignment.
-     * Layer 1: highest-priority coaches only.
-     * Layer 2: weighted booking shortfall (target = total × weight/totalWeight).
-     * Layer 3: tiebreak by least-recently-assigned.
-     */
-    async findBestCoach(db, organizationId) {
-        const all = await this.getCoachAssignmentConfig(db, organizationId);
-        let candidates = all.filter((c) => c.isAvailableForAssignment);
-        if (candidates.length === 0) {
-            throw new Error('No available coaches found');
-        }
-        // Filter by max_active_tracks
-        candidates = candidates.filter((c) => c.maxActiveTracks == null || c.activeTracks < c.maxActiveTracks);
-        if (candidates.length === 0) {
-            throw new Error('All coaches at maximum capacity');
-        }
-        // Layer 1: keep only highest priority
-        const maxPriority = Math.max(...candidates.map((c) => c.priority));
-        candidates = candidates.filter((c) => c.priority === maxPriority);
-        // Layer 2: weighted shortfall
-        const totalActive = candidates.reduce((sum, c) => sum + c.activeTracks, 0);
-        const totalWeight = candidates.reduce((sum, c) => sum + c.weight, 0);
-        let best = null;
-        let bestShortfall = -Infinity;
-        let bestLast = Infinity;
-        for (const c of candidates) {
-            const target = totalWeight > 0 ? totalActive * (c.weight / totalWeight) : 0;
-            const shortfall = target - c.activeTracks;
-            const lastTs = c.lastAssignedAt ? new Date(c.lastAssignedAt).getTime() : 0;
-            if (shortfall > bestShortfall ||
-                (shortfall === bestShortfall && lastTs < bestLast)) {
-                best = c;
-                bestShortfall = shortfall;
-                bestLast = lastTs;
-            }
-        }
-        if (!best)
-            throw new Error('No best coach could be determined');
-        // Stamp last_assigned_at
-        await db
-            .from('planner_coach_assignment_config')
-            .upsert({
-            organization_id: organizationId,
-            coach_id: best.coachId,
-            last_assigned_at: new Date().toISOString(),
-            updated_at: new Date().toISOString(),
-        }, { onConflict: 'organization_id,coach_id' });
-        return {
-            coachId: best.coachId,
-            coachName: best.name,
-            reason: `Lowest workload (${best.activeTracks} active tracks, weight ${best.weight}, priority ${best.priority})`,
-            shortfall: bestShortfall,
-            activeTracks: best.activeTracks,
-            weight: best.weight,
-            priority: best.priority,
-        };
-    }
-    // ─── Calendar Cache (Phase 4) ────────────────────────────────
-    /**
-     * Upsert events into the cache for a user/calendar.
-     * Replaces all existing cache entries for that calendar in the given window.
-     */
-    async upsertCalendarCache(db, userId, organizationId, externalCalendarId, events, window) {
-        if (window) {
-            await db
-                .from('planner_calendar_cache')
-                .delete()
-                .eq('user_id', userId)
-                .eq('external_calendar_id', externalCalendarId)
-                .gte('event_start', window.from)
-                .lte('event_end', window.to);
-        }
-        if (events.length === 0)
-            return 0;
-        const rows = events.map((e) => ({
-            user_id: userId,
-            organization_id: organizationId,
-            external_calendar_id: externalCalendarId,
-            external_event_id: e.externalEventId,
-            event_start: e.eventStart,
-            event_end: e.eventEnd,
-            is_all_day: e.isAllDay ?? false,
-            status: e.status ?? 'confirmed',
-            summary: e.summary ?? null,
-            synced_at: new Date().toISOString(),
-        }));
-        const { error } = await db
-            .from('planner_calendar_cache')
-            .upsert(rows, { onConflict: 'user_id,external_calendar_id,external_event_id' });
-        if (error) {
-            logger.error({ error, userId, externalCalendarId }, 'Failed to upsert calendar cache');
-            throw new Error('Failed to cache calendar events');
-        }
-        return rows.length;
-    }
-    /**
-     * Read cached events for a user across selected calendars.
-     */
-    async getCachedBusySlots(db, userId, dateFrom, dateTo) {
-        const { data, error } = await db
-            .from('planner_calendar_cache')
-            .select('event_start, event_end, summary, status')
-            .eq('user_id', userId)
-            .neq('status', 'cancelled')
-            .gte('event_end', `${dateFrom}T00:00:00Z`)
-            .lte('event_start', `${dateTo}T23:59:59Z`);
-        if (error) {
-            logger.warn({ error, userId }, 'Failed to read calendar cache');
-            return [];
-        }
-        return (data || []).map((r) => ({
-            start_time: r.event_start,
-            end_time: r.event_end,
-            summary: r.summary,
-        }));
-    }
-}
-// ─── Helpers ─────────────────────────────────────────────────
-function isoWeekKey(date) {
-    // ISO week year + week number
-    const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
-    const dayNum = d.getUTCDay() || 7;
-    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
-    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
-    const weekNo = Math.ceil(((d.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
-    return `${d.getUTCFullYear()}-W${String(weekNo).padStart(2, '0')}`;
-}
-//# sourceMappingURL=PlannerService.js.map