@voyantjs/bookings 0.1.0

package/dist/service.js

@@ -0,0 +1,2016 @@
+import { and, asc, desc, eq, ilike, inArray, lte, ne, or, sql } from "drizzle-orm";
+import { availabilitySlotsRef } from "./availability-ref.js";
+import { bookingItemProductDetailsRef, bookingProductDetailsRef, optionUnitsRef, productDayServicesRef, productDaysRef, productOptionsRef, productTicketSettingsRef, productsRef, } from "./products-ref.js";
+import { bookingActivityLog, bookingAllocations, bookingDocuments, bookingFulfillments, bookingItemParticipants, bookingItems, bookingNotes, bookingParticipants, bookingRedemptionEvents, bookingSupplierStatuses, bookings, } from "./schema.js";
+import { bookingTransactionDetailsRef, offerItemParticipantsRef, offerItemsRef, offerParticipantsRef, offersRef, orderItemParticipantsRef, orderItemsRef, orderParticipantsRef, ordersRef, } from "./transactions-ref.js";
+const travelerParticipantTypes = ["traveler", "occupant"];
+class BookingServiceError extends Error {
+    code;
+    constructor(code, message) {
+        super(message ?? code);
+        this.code = code;
+        this.name = "BookingServiceError";
+    }
+}
+function toTimestamp(value) {
+    return value ? new Date(value) : null;
+}
+function toDateValue(value) {
+    return value instanceof Date ? value : new Date(value);
+}
+function toDateValueOrNull(value) {
+    if (!value)
+        return null;
+    return value instanceof Date ? value : new Date(value);
+}
+function toPassengerResponse(participant) {
+    return {
+        id: participant.id,
+        bookingId: participant.bookingId,
+        firstName: participant.firstName,
+        lastName: participant.lastName,
+        email: participant.email,
+        phone: participant.phone,
+        specialRequests: participant.specialRequests,
+        isLeadPassenger: participant.isPrimary,
+        createdAt: participant.createdAt,
+        updatedAt: participant.updatedAt,
+    };
+}
+function toCreateParticipantFromPassenger(data) {
+    return {
+        participantType: "traveler",
+        firstName: data.firstName,
+        lastName: data.lastName,
+        email: data.email ?? null,
+        phone: data.phone ?? null,
+        specialRequests: data.specialRequests ?? null,
+        isPrimary: data.isLeadPassenger ?? false,
+    };
+}
+function toUpdateParticipantFromPassenger(data) {
+    return {
+        firstName: data.firstName,
+        lastName: data.lastName,
+        email: data.email ?? null,
+        phone: data.phone ?? null,
+        specialRequests: data.specialRequests ?? null,
+        isPrimary: data.isLeadPassenger ?? undefined,
+    };
+}
+async function ensureParticipantFlags(db, bookingId, participantId, data) {
+    if (data.isPrimary) {
+        await db
+            .update(bookingParticipants)
+            .set({ isPrimary: false, updatedAt: new Date() })
+            .where(and(eq(bookingParticipants.bookingId, bookingId), ne(bookingParticipants.id, participantId)));
+    }
+}
+async function ensureBookingScopedLinks(db, bookingId, data) {
+    if (data.bookingItemId) {
+        const [item] = await db
+            .select({ id: bookingItems.id })
+            .from(bookingItems)
+            .where(and(eq(bookingItems.id, data.bookingItemId), eq(bookingItems.bookingId, bookingId)))
+            .limit(1);
+        if (!item) {
+            return { ok: false, reason: "booking_item_not_found" };
+        }
+    }
+    if (data.participantId) {
+        const [participant] = await db
+            .select({ id: bookingParticipants.id })
+            .from(bookingParticipants)
+            .where(and(eq(bookingParticipants.id, data.participantId), eq(bookingParticipants.bookingId, bookingId)))
+            .limit(1);
+        if (!participant) {
+            return { ok: false, reason: "participant_not_found" };
+        }
+    }
+    return { ok: true };
+}
+function deriveBookingDateRange(items) {
+    const dates = items
+        .flatMap((item) => [item.serviceDate, item.startsAt?.toISOString().slice(0, 10) ?? null])
+        .filter((value) => Boolean(value))
+        .sort();
+    return {
+        startDate: dates[0] ?? null,
+        endDate: dates[dates.length - 1] ?? null,
+    };
+}
+function deriveBookingPax(participants, items) {
+    const pax = participants.filter((participant) => ["traveler", "occupant"].includes(participant.participantType)).length;
+    if (pax > 0) {
+        return pax;
+    }
+    return items
+        .filter((item) => item.itemType === "unit")
+        .reduce((sum, item) => sum + item.quantity, 0);
+}
+function getTransactionItemParticipantItemId(link) {
+    return "offerItemId" in link ? link.offerItemId : link.orderItemId;
+}
+function mapDeliveryFormatToFulfillment(format) {
+    switch (format) {
+        case "pdf":
+            return { fulfillmentType: "pdf", deliveryChannel: "download" };
+        case "qr_code":
+            return { fulfillmentType: "qr_code", deliveryChannel: "download" };
+        case "barcode":
+            return { fulfillmentType: "barcode", deliveryChannel: "download" };
+        case "mobile":
+            return { fulfillmentType: "mobile", deliveryChannel: "wallet" };
+        case "email":
+            return { fulfillmentType: "voucher", deliveryChannel: "email" };
+        case "ticket":
+            return { fulfillmentType: "ticket", deliveryChannel: "download" };
+        case "voucher":
+        default:
+            return { fulfillmentType: "voucher", deliveryChannel: "download" };
+    }
+}
+async function getConvertProductData(db, data) {
+    const [product] = await db
+        .select()
+        .from(productsRef)
+        .where(eq(productsRef.id, data.productId))
+        .limit(1);
+    if (!product) {
+        return null;
+    }
+    let option = null;
+    if (data.optionId) {
+        const [selectedOption] = await db
+            .select()
+            .from(productOptionsRef)
+            .where(and(eq(productOptionsRef.id, data.optionId), eq(productOptionsRef.productId, product.id)))
+            .limit(1);
+        if (!selectedOption) {
+            return null;
+        }
+        option = selectedOption;
+    }
+    else {
+        const [defaultOption] = await db
+            .select()
+            .from(productOptionsRef)
+            .where(eq(productOptionsRef.productId, product.id))
+            .orderBy(desc(productOptionsRef.isDefault), asc(productOptionsRef.sortOrder), asc(productOptionsRef.createdAt))
+            .limit(1);
+        option = defaultOption ?? null;
+    }
+    const days = await db
+        .select()
+        .from(productDaysRef)
+        .where(eq(productDaysRef.productId, product.id))
+        .orderBy(asc(productDaysRef.dayNumber));
+    const dayServices = days.length
+        ? await db
+            .select({
+            supplierServiceId: productDayServicesRef.supplierServiceId,
+            name: productDayServicesRef.name,
+            costCurrency: productDayServicesRef.costCurrency,
+            costAmountCents: productDayServicesRef.costAmountCents,
+        })
+            .from(productDayServicesRef)
+            .where(sql `${productDayServicesRef.dayId} IN (
+            SELECT ${productDaysRef.id}
+            FROM ${productDaysRef}
+            WHERE ${productDaysRef.productId} = ${product.id}
+          )`)
+            .orderBy(asc(productDayServicesRef.sortOrder), asc(productDayServicesRef.id))
+        : [];
+    const units = option === null
+        ? []
+        : await db
+            .select()
+            .from(optionUnitsRef)
+            .where(eq(optionUnitsRef.optionId, option.id))
+            .orderBy(asc(optionUnitsRef.sortOrder), asc(optionUnitsRef.createdAt));
+    return {
+        product: {
+            id: product.id,
+            name: product.name,
+            description: product.description,
+            sellCurrency: product.sellCurrency,
+            sellAmountCents: product.sellAmountCents,
+            costAmountCents: product.costAmountCents,
+            marginPercent: product.marginPercent,
+            startDate: product.startDate,
+            endDate: product.endDate,
+            pax: product.pax,
+        },
+        option: option ? { id: option.id, name: option.name } : null,
+        dayServices,
+        units: units.map((unit) => ({
+            id: unit.id,
+            name: unit.name,
+            description: unit.description,
+            unitType: unit.unitType,
+            isRequired: unit.isRequired,
+            minQuantity: unit.minQuantity,
+            sortOrder: unit.sortOrder,
+        })),
+    };
+}
+const VALID_BOOKING_TRANSITIONS = {
+    draft: ["on_hold", "confirmed", "cancelled"],
+    on_hold: ["confirmed", "expired", "cancelled"],
+    confirmed: ["in_progress", "cancelled"],
+    in_progress: ["completed", "cancelled"],
+    completed: [],
+    expired: [],
+    cancelled: [],
+};
+function isValidBookingTransition(from, to) {
+    return VALID_BOOKING_TRANSITIONS[from].includes(to);
+}
+function computeHoldExpiresAt(input) {
+    if (input.holdExpiresAt) {
+        return new Date(input.holdExpiresAt);
+    }
+    const now = Date.now();
+    const minutes = input.holdMinutes ?? 30;
+    return new Date(now + minutes * 60 * 1000);
+}
+function toBookingStatusTimestamps(status) {
+    const now = new Date();
+    return {
+        confirmedAt: status === "confirmed" ? now : undefined,
+        expiredAt: status === "expired" ? now : undefined,
+        cancelledAt: status === "cancelled" ? now : undefined,
+        completedAt: status === "completed" ? now : undefined,
+    };
+}
+async function lockAvailabilitySlot(db, slotId) {
+    const rows = await db.execute(sql `SELECT id, product_id, option_id, date_local, starts_at, ends_at, timezone, status, unlimited, remaining_pax
+        FROM ${availabilitySlotsRef}
+        WHERE ${availabilitySlotsRef.id} = ${slotId}
+        FOR UPDATE`);
+    const row = rows[0];
+    if (!row) {
+        return null;
+    }
+    return {
+        ...row,
+        starts_at: toDateValue(row.starts_at),
+        ends_at: toDateValueOrNull(row.ends_at),
+    };
+}
+async function adjustSlotCapacity(db, slotId, delta) {
+    const locked = await lockAvailabilitySlot(db, slotId);
+    if (!locked) {
+        return { status: "slot_not_found" };
+    }
+    if (locked.status !== "open" && locked.status !== "sold_out") {
+        return { status: "slot_unavailable", slot: locked };
+    }
+    if (locked.unlimited) {
+        return { status: "ok", slot: locked, remainingPax: locked.remaining_pax };
+    }
+    const currentRemaining = locked.remaining_pax ?? 0;
+    const nextRemaining = currentRemaining + delta;
+    if (nextRemaining < 0) {
+        return { status: "insufficient_capacity", slot: locked, remainingPax: currentRemaining };
+    }
+    let nextStatus = locked.status;
+    if (nextRemaining === 0 && locked.status === "open") {
+        nextStatus = "sold_out";
+    }
+    else if (nextRemaining > 0 && locked.status === "sold_out") {
+        nextStatus = "open";
+    }
+    await db
+        .update(availabilitySlotsRef)
+        .set({
+        remainingPax: nextRemaining,
+        status: nextStatus,
+        updatedAt: new Date(),
+    })
+        .where(eq(availabilitySlotsRef.id, slotId));
+    return { status: "ok", slot: locked, remainingPax: nextRemaining };
+}
+async function releaseAllocationCapacity(db, allocation) {
+    if (!allocation.availabilitySlotId) {
+        return;
+    }
+    if (allocation.status !== "held" && allocation.status !== "confirmed") {
+        return;
+    }
+    await adjustSlotCapacity(db, allocation.availabilitySlotId, allocation.quantity);
+}
+async function reserveBookingFromTransactionSource(db, source, data, userId) {
+    try {
+        return await db.transaction(async (tx) => {
+            const holdExpiresAt = computeHoldExpiresAt(data);
+            const dateRange = deriveBookingDateRange(source.items);
+            const pax = deriveBookingPax(source.participants, source.items);
+            const [booking] = await tx
+                .insert(bookings)
+                .values({
+                bookingNumber: data.bookingNumber,
+                status: "on_hold",
+                personId: source.personId,
+                organizationId: source.organizationId,
+                sourceType: data.sourceType,
+                sellCurrency: source.currency,
+                baseCurrency: source.baseCurrency,
+                sellAmountCents: source.totalAmountCents,
+                costAmountCents: source.costAmountCents,
+                startDate: dateRange.startDate,
+                endDate: dateRange.endDate,
+                pax: pax > 0 ? pax : null,
+                internalNotes: data.internalNotes ?? source.notes,
+                holdExpiresAt,
+            })
+                .returning();
+            if (!booking) {
+                throw new BookingServiceError("booking_create_failed");
+            }
+            const participantMap = new Map();
+            if (data.includeParticipants) {
+                for (const participant of source.participants) {
+                    const [createdParticipant] = await tx
+                        .insert(bookingParticipants)
+                        .values({
+                        bookingId: booking.id,
+                        personId: participant.personId ?? null,
+                        participantType: participant.participantType,
+                        travelerCategory: participant.travelerCategory ?? null,
+                        firstName: participant.firstName,
+                        lastName: participant.lastName,
+                        email: participant.email ?? null,
+                        phone: participant.phone ?? null,
+                        preferredLanguage: participant.preferredLanguage ?? null,
+                        isPrimary: participant.isPrimary,
+                        notes: participant.notes ?? null,
+                    })
+                        .returning();
+                    if (!createdParticipant) {
+                        throw new BookingServiceError("participant_create_failed");
+                    }
+                    participantMap.set(participant.id, createdParticipant.id);
+                }
+            }
+            const bookingItemMap = new Map();
+            for (const item of source.items) {
+                if (item.slotId) {
+                    const capacity = await adjustSlotCapacity(tx, item.slotId, -item.quantity);
+                    if (capacity.status === "slot_not_found") {
+                        throw new BookingServiceError("slot_not_found");
+                    }
+                    if (capacity.status === "slot_unavailable") {
+                        throw new BookingServiceError("slot_unavailable");
+                    }
+                    if (capacity.status === "insufficient_capacity") {
+                        throw new BookingServiceError("insufficient_capacity");
+                    }
+                    const slot = capacity.slot;
+                    if (item.productId && item.productId !== slot.product_id) {
+                        throw new BookingServiceError("slot_product_mismatch");
+                    }
+                    if (item.optionId && item.optionId !== slot.option_id) {
+                        throw new BookingServiceError("slot_option_mismatch");
+                    }
+                }
+                const [bookingItem] = await tx
+                    .insert(bookingItems)
+                    .values({
+                    bookingId: booking.id,
+                    title: item.title,
+                    description: item.description ?? null,
+                    itemType: item.itemType,
+                    status: "on_hold",
+                    serviceDate: item.serviceDate ?? (item.slotId ? undefined : null),
+                    startsAt: item.startsAt ?? null,
+                    endsAt: item.endsAt ?? null,
+                    quantity: item.quantity,
+                    sellCurrency: item.sellCurrency,
+                    unitSellAmountCents: item.unitSellAmountCents ?? null,
+                    totalSellAmountCents: item.totalSellAmountCents ?? null,
+                    costCurrency: item.costCurrency ?? null,
+                    unitCostAmountCents: item.unitCostAmountCents ?? null,
+                    totalCostAmountCents: item.totalCostAmountCents ?? null,
+                    notes: item.notes ?? null,
+                    productId: item.productId ?? null,
+                    optionId: item.optionId ?? null,
+                    optionUnitId: item.unitId ?? null,
+                    sourceOfferId: source.offerId,
+                    metadata: item.metadata ?? null,
+                })
+                    .returning();
+                if (!bookingItem) {
+                    throw new BookingServiceError("booking_item_create_failed");
+                }
+                bookingItemMap.set(item.id, bookingItem.id);
+                if (item.slotId) {
+                    const [allocation] = await tx
+                        .insert(bookingAllocations)
+                        .values({
+                        bookingId: booking.id,
+                        bookingItemId: bookingItem.id,
+                        productId: item.productId ?? null,
+                        optionId: item.optionId ?? null,
+                        optionUnitId: item.unitId ?? null,
+                        availabilitySlotId: item.slotId,
+                        quantity: item.quantity,
+                        allocationType: "unit",
+                        status: "held",
+                        holdExpiresAt,
+                        metadata: item.metadata ?? null,
+                    })
+                        .returning();
+                    if (!allocation) {
+                        throw new BookingServiceError("allocation_create_failed");
+                    }
+                }
+            }
+            for (const link of source.itemParticipants) {
+                const sourceItemId = getTransactionItemParticipantItemId(link);
+                if (!sourceItemId) {
+                    continue;
+                }
+                const bookingItemId = bookingItemMap.get(sourceItemId);
+                const participantId = participantMap.get(link.participantId);
+                if (!bookingItemId || !participantId) {
+                    continue;
+                }
+                await tx.insert(bookingItemParticipants).values({
+                    bookingItemId,
+                    participantId,
+                    role: link.role,
+                    isPrimary: link.isPrimary,
+                });
+            }
+            await tx
+                .insert(bookingTransactionDetailsRef)
+                .values({
+                bookingId: booking.id,
+                offerId: source.offerId,
+                orderId: source.orderId,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            })
+                .onConflictDoUpdate({
+                target: bookingTransactionDetailsRef.bookingId,
+                set: {
+                    offerId: source.offerId,
+                    orderId: source.orderId,
+                    updatedAt: new Date(),
+                },
+            });
+            await tx.insert(bookingActivityLog).values({
+                bookingId: booking.id,
+                actorId: userId ?? "system",
+                activityType: "booking_reserved",
+                description: `Booking ${booking.bookingNumber} reserved from ${source.kind} ${source.sourceId}`,
+                metadata: {
+                    sourceKind: source.kind,
+                    sourceId: source.sourceId,
+                    offerId: source.offerId,
+                    orderId: source.orderId,
+                    holdExpiresAt: holdExpiresAt.toISOString(),
+                    itemCount: source.items.length,
+                },
+            });
+            if (data.note) {
+                await tx.insert(bookingNotes).values({
+                    bookingId: booking.id,
+                    authorId: userId ?? "system",
+                    content: data.note,
+                });
+            }
+            return { status: "ok", booking };
+        });
+    }
+    catch (error) {
+        if (error instanceof BookingServiceError) {
+            return { status: error.code };
+        }
+        throw error;
+    }
+}
+async function getBookingTransactionLink(db, bookingId) {
+    const [link] = await db
+        .select()
+        .from(bookingTransactionDetailsRef)
+        .where(eq(bookingTransactionDetailsRef.bookingId, bookingId))
+        .limit(1);
+    return link ?? null;
+}
+async function syncTransactionOnBookingConfirmed(db, bookingId) {
+    const link = await getBookingTransactionLink(db, bookingId);
+    if (!link) {
+        return;
+    }
+    const now = new Date();
+    if (link.orderId) {
+        await db
+            .update(ordersRef)
+            .set({
+            status: "confirmed",
+            confirmedAt: now,
+            updatedAt: now,
+        })
+            .where(eq(ordersRef.id, link.orderId));
+    }
+    if (link.offerId) {
+        await db
+            .update(offersRef)
+            .set({
+            status: "converted",
+            acceptedAt: now,
+            convertedAt: now,
+            updatedAt: now,
+        })
+            .where(eq(offersRef.id, link.offerId));
+    }
+}
+async function syncTransactionOnBookingExpired(db, bookingId) {
+    const link = await getBookingTransactionLink(db, bookingId);
+    if (!link?.orderId) {
+        return;
+    }
+    const now = new Date();
+    await db
+        .update(ordersRef)
+        .set({
+        status: "expired",
+        expiresAt: now,
+        updatedAt: now,
+    })
+        .where(eq(ordersRef.id, link.orderId));
+}
+async function syncTransactionOnBookingCancelled(db, bookingId) {
+    const link = await getBookingTransactionLink(db, bookingId);
+    if (!link?.orderId) {
+        return;
+    }
+    const now = new Date();
+    await db
+        .update(ordersRef)
+        .set({
+        status: "cancelled",
+        cancelledAt: now,
+        updatedAt: now,
+    })
+        .where(eq(ordersRef.id, link.orderId));
+}
+async function syncTransactionOnBookingRedeemed(db, bookingId) {
+    const link = await getBookingTransactionLink(db, bookingId);
+    if (!link?.orderId) {
+        return;
+    }
+    await db
+        .update(ordersRef)
+        .set({
+        status: "fulfilled",
+        updatedAt: new Date(),
+    })
+        .where(eq(ordersRef.id, link.orderId));
+}
+async function autoIssueFulfillmentsForBooking(db, bookingId, userId) {
+    const [booking] = await db
+        .select({
+        id: bookings.id,
+        bookingNumber: bookings.bookingNumber,
+    })
+        .from(bookings)
+        .where(eq(bookings.id, bookingId))
+        .limit(1);
+    if (!booking) {
+        return;
+    }
+    const existingFulfillment = await db
+        .select({ id: bookingFulfillments.id })
+        .from(bookingFulfillments)
+        .where(eq(bookingFulfillments.bookingId, bookingId))
+        .limit(1);
+    if (existingFulfillment.length > 0) {
+        return;
+    }
+    const items = await db
+        .select()
+        .from(bookingItems)
+        .where(and(eq(bookingItems.bookingId, bookingId), sql `${bookingItems.productId} IS NOT NULL`))
+        .orderBy(asc(bookingItems.createdAt));
+    if (items.length === 0) {
+        return;
+    }
+    const productIds = [...new Set(items.map((item) => item.productId).filter((value) => Boolean(value)))];
+    if (productIds.length === 0) {
+        return;
+    }
+    const settings = await db
+        .select()
+        .from(productTicketSettingsRef)
+        .where(inArray(productTicketSettingsRef.productId, productIds));
+    const settingsByProductId = new Map(settings.map((setting) => [setting.productId, setting]));
+    const travelerParticipants = await db
+        .select()
+        .from(bookingParticipants)
+        .where(and(eq(bookingParticipants.bookingId, bookingId), or(eq(bookingParticipants.participantType, "traveler"), eq(bookingParticipants.participantType, "occupant"))))
+        .orderBy(desc(bookingParticipants.isPrimary), asc(bookingParticipants.createdAt));
+    const participantLinks = await db
+        .select()
+        .from(bookingItemParticipants)
+        .where(sql `${bookingItemParticipants.bookingItemId} IN (
+        SELECT ${bookingItems.id}
+        FROM ${bookingItems}
+        WHERE ${bookingItems.bookingId} = ${bookingId}
+      )`);
+    const participantLinksByItemId = new Map();
+    for (const link of participantLinks) {
+        const links = participantLinksByItemId.get(link.bookingItemId) ?? [];
+        links.push(link);
+        participantLinksByItemId.set(link.bookingItemId, links);
+    }
+    const fulfillmentsToInsert = [];
+    const now = new Date();
+    for (const item of items) {
+        const productId = item.productId;
+        if (!productId) {
+            continue;
+        }
+        const setting = settingsByProductId.get(productId);
+        if (!setting || setting.fulfillmentMode === "none" || setting.defaultDeliveryFormat === "none") {
+            continue;
+        }
+        const delivery = mapDeliveryFormatToFulfillment(setting.defaultDeliveryFormat);
+        const payloadBase = {
+            bookingId,
+            bookingNumber: booking.bookingNumber,
+            productId,
+            bookingItemId: item.id,
+        };
+        if (setting.fulfillmentMode === "per_booking") {
+            if (fulfillmentsToInsert.some((row) => row.bookingItemId === item.id || row.bookingItemId === null)) {
+                continue;
+            }
+            fulfillmentsToInsert.push({
+                bookingId,
+                bookingItemId: item.id,
+                participantId: null,
+                fulfillmentType: delivery.fulfillmentType,
+                deliveryChannel: delivery.deliveryChannel,
+                status: "issued",
+                payload: { ...payloadBase, scope: "booking" },
+                issuedAt: now,
+            });
+            continue;
+        }
+        if (setting.fulfillmentMode === "per_item") {
+            fulfillmentsToInsert.push({
+                bookingId,
+                bookingItemId: item.id,
+                participantId: null,
+                fulfillmentType: delivery.fulfillmentType,
+                deliveryChannel: delivery.deliveryChannel,
+                status: "issued",
+                payload: { ...payloadBase, scope: "item" },
+                issuedAt: now,
+            });
+            continue;
+        }
+        const linkedParticipants = participantLinksByItemId
+            .get(item.id)
+            ?.map((link) => travelerParticipants.find((participant) => participant.id === link.participantId))
+            .filter((participant) => Boolean(participant)) ??
+            [];
+        const participantsForItem = linkedParticipants.length > 0 ? linkedParticipants : travelerParticipants;
+        for (const participant of participantsForItem) {
+            fulfillmentsToInsert.push({
+                bookingId,
+                bookingItemId: item.id,
+                participantId: participant.id,
+                fulfillmentType: delivery.fulfillmentType,
+                deliveryChannel: delivery.deliveryChannel,
+                status: "issued",
+                payload: {
+                    ...payloadBase,
+                    participantId: participant.id,
+                    scope: "participant",
+                },
+                issuedAt: now,
+            });
+        }
+    }
+    if (fulfillmentsToInsert.length === 0) {
+        return;
+    }
+    await db.insert(bookingFulfillments).values(fulfillmentsToInsert);
+    await db.insert(bookingActivityLog).values({
+        bookingId,
+        actorId: userId ?? "system",
+        activityType: "fulfillment_issued",
+        description: `${fulfillmentsToInsert.length} fulfillment artifact(s) issued automatically`,
+        metadata: { count: fulfillmentsToInsert.length },
+    });
+}
+export const bookingsService = {
+    async listBookings(db, query) {
+        const conditions = [];
+        if (query.status) {
+            conditions.push(eq(bookings.status, query.status));
+        }
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(bookings.bookingNumber, term), ilike(bookings.internalNotes, term)));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(bookings)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(desc(bookings.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(bookings).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async convertProductToBooking(db, data, productData, userId) {
+        const { product, option, dayServices, units } = productData;
+        const [booking] = await db
+            .insert(bookings)
+            .values({
+            bookingNumber: data.bookingNumber,
+            status: "draft",
+            personId: data.personId ?? null,
+            organizationId: data.organizationId ?? null,
+            sellCurrency: product.sellCurrency,
+            sellAmountCents: product.sellAmountCents,
+            costAmountCents: product.costAmountCents,
+            marginPercent: product.marginPercent,
+            startDate: product.startDate,
+            endDate: product.endDate,
+            pax: product.pax,
+            internalNotes: data.internalNotes ?? null,
+        })
+            .returning();
+        if (!booking) {
+            return null;
+        }
+        if (dayServices.length > 0) {
+            await db.insert(bookingSupplierStatuses).values(dayServices.map((service) => ({
+                bookingId: booking.id,
+                supplierServiceId: service.supplierServiceId,
+                serviceName: service.name,
+                status: "pending",
+                costCurrency: service.costCurrency,
+                costAmountCents: service.costAmountCents,
+            })));
+        }
+        const selectedUnits = option === null ? [] : units;
+        const unitsToSeed = selectedUnits.filter((unit) => unit.isRequired).length > 0
+            ? selectedUnits.filter((unit) => unit.isRequired)
+            : selectedUnits.length === 1
+                ? selectedUnits
+                : [];
+        const itemRows = unitsToSeed.length > 0
+            ? unitsToSeed.map((unit, index) => {
+                const quantity = unit.unitType === "person" && product.pax
+                    ? product.pax
+                    : unit.minQuantity && unit.minQuantity > 0
+                        ? unit.minQuantity
+                        : 1;
+                const singleSeedItem = unitsToSeed.length === 1 && index === 0;
+                return {
+                    bookingId: booking.id,
+                    title: unit.name,
+                    description: unit.description,
+                    itemType: "unit",
+                    status: "draft",
+                    quantity,
+                    sellCurrency: product.sellCurrency,
+                    unitSellAmountCents: singleSeedItem &&
+                        product.sellAmountCents !== null &&
+                        product.sellAmountCents !== undefined
+                        ? Math.floor(product.sellAmountCents / quantity)
+                        : null,
+                    totalSellAmountCents: singleSeedItem ? (product.sellAmountCents ?? null) : null,
+                    costCurrency: singleSeedItem ? product.sellCurrency : null,
+                    unitCostAmountCents: singleSeedItem &&
+                        product.costAmountCents !== null &&
+                        product.costAmountCents !== undefined
+                        ? Math.floor(product.costAmountCents / quantity)
+                        : null,
+                    totalCostAmountCents: singleSeedItem ? (product.costAmountCents ?? null) : null,
+                    productId: product.id,
+                    optionId: option?.id ?? null,
+                    optionUnitId: unit.id,
+                };
+            })
+            : [
+                {
+                    bookingId: booking.id,
+                    title: option?.name ?? product.name,
+                    description: product.description,
+                    itemType: "unit",
+                    status: "draft",
+                    quantity: 1,
+                    sellCurrency: product.sellCurrency,
+                    unitSellAmountCents: product.sellAmountCents ?? null,
+                    totalSellAmountCents: product.sellAmountCents ?? null,
+                    costCurrency: product.sellCurrency,
+                    unitCostAmountCents: product.costAmountCents ?? null,
+                    totalCostAmountCents: product.costAmountCents ?? null,
+                    productId: product.id,
+                    optionId: option?.id ?? null,
+                    optionUnitId: null,
+                },
+            ];
+        const insertedItems = await db.insert(bookingItems).values(itemRows).returning();
+        await db
+            .insert(bookingProductDetailsRef)
+            .values({
+            bookingId: booking.id,
+            productId: product.id,
+            optionId: option?.id ?? null,
+        })
+            .onConflictDoUpdate({
+            target: bookingProductDetailsRef.bookingId,
+            set: {
+                productId: product.id,
+                optionId: option?.id ?? null,
+                updatedAt: new Date(),
+            },
+        });
+        if (insertedItems.length > 0) {
+            await db.insert(bookingItemProductDetailsRef).values(insertedItems.map((item) => ({
+                bookingItemId: item.id,
+                productId: item.productId ?? null,
+                optionId: item.optionId ?? null,
+                unitId: item.optionUnitId ?? null,
+                supplierServiceId: null,
+            })));
+        }
+        await db.insert(bookingActivityLog).values({
+            bookingId: booking.id,
+            actorId: userId ?? "system",
+            activityType: "booking_converted",
+            description: `Booking converted from product "${product.name}"`,
+            metadata: { productId: product.id, productName: product.name, optionId: option?.id ?? null },
+        });
+        return booking;
+    },
+    async getBookingById(db, id) {
+        const [row] = await db.select().from(bookings).where(eq(bookings.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createBookingFromProduct(db, data, userId) {
+        const productData = await getConvertProductData(db, data);
+        if (!productData) {
+            return null;
+        }
+        return this.convertProductToBooking(db, data, productData, userId);
+    },
+    listAllocations(db, bookingId) {
+        return db
+            .select()
+            .from(bookingAllocations)
+            .where(eq(bookingAllocations.bookingId, bookingId))
+            .orderBy(asc(bookingAllocations.createdAt));
+    },
+    async reserveBookingFromOffer(db, offerId, data, userId) {
+        const [offer] = await db.select().from(offersRef).where(eq(offersRef.id, offerId)).limit(1);
+        if (!offer) {
+            return { status: "not_found" };
+        }
+        const [participants, items, itemParticipants] = await Promise.all([
+            db
+                .select()
+                .from(offerParticipantsRef)
+                .where(eq(offerParticipantsRef.offerId, offerId))
+                .orderBy(asc(offerParticipantsRef.createdAt)),
+            db
+                .select()
+                .from(offerItemsRef)
+                .where(eq(offerItemsRef.offerId, offerId))
+                .orderBy(asc(offerItemsRef.createdAt)),
+            db
+                .select()
+                .from(offerItemParticipantsRef)
+                .where(sql `${offerItemParticipantsRef.offerItemId} IN (
+            SELECT ${offerItemsRef.id}
+            FROM ${offerItemsRef}
+            WHERE ${offerItemsRef.offerId} = ${offerId}
+          )`)
+                .orderBy(asc(offerItemParticipantsRef.createdAt)),
+        ]);
+        return reserveBookingFromTransactionSource(db, {
+            kind: "offer",
+            sourceId: offerId,
+            offerId: offer.id,
+            orderId: null,
+            personId: offer.personId ?? null,
+            organizationId: offer.organizationId ?? null,
+            currency: offer.currency,
+            baseCurrency: offer.baseCurrency ?? null,
+            totalAmountCents: offer.totalAmountCents ?? null,
+            costAmountCents: offer.costAmountCents ?? null,
+            notes: offer.notes ?? null,
+            participants,
+            items,
+            itemParticipants,
+        }, data, userId);
+    },
+    async reserveBookingFromOrder(db, orderId, data, userId) {
+        const [order] = await db.select().from(ordersRef).where(eq(ordersRef.id, orderId)).limit(1);
+        if (!order) {
+            return { status: "not_found" };
+        }
+        const [participants, items, itemParticipants] = await Promise.all([
+            db
+                .select()
+                .from(orderParticipantsRef)
+                .where(eq(orderParticipantsRef.orderId, orderId))
+                .orderBy(asc(orderParticipantsRef.createdAt)),
+            db
+                .select()
+                .from(orderItemsRef)
+                .where(eq(orderItemsRef.orderId, orderId))
+                .orderBy(asc(orderItemsRef.createdAt)),
+            db
+                .select()
+                .from(orderItemParticipantsRef)
+                .where(sql `${orderItemParticipantsRef.orderItemId} IN (
+            SELECT ${orderItemsRef.id}
+            FROM ${orderItemsRef}
+            WHERE ${orderItemsRef.orderId} = ${orderId}
+          )`)
+                .orderBy(asc(orderItemParticipantsRef.createdAt)),
+        ]);
+        return reserveBookingFromTransactionSource(db, {
+            kind: "order",
+            sourceId: orderId,
+            offerId: order.offerId ?? null,
+            orderId: order.id,
+            personId: order.personId ?? null,
+            organizationId: order.organizationId ?? null,
+            currency: order.currency,
+            baseCurrency: order.baseCurrency ?? null,
+            totalAmountCents: order.totalAmountCents ?? null,
+            costAmountCents: order.costAmountCents ?? null,
+            notes: order.notes ?? null,
+            participants,
+            items,
+            itemParticipants,
+        }, data, userId);
+    },
+    async reserveBooking(db, data, userId) {
+        try {
+            return await db.transaction(async (tx) => {
+                const holdExpiresAt = computeHoldExpiresAt(data);
+                const [booking] = await tx
+                    .insert(bookings)
+                    .values({
+                    bookingNumber: data.bookingNumber,
+                    status: "on_hold",
+                    personId: data.personId ?? null,
+                    organizationId: data.organizationId ?? null,
+                    sourceType: data.sourceType,
+                    externalBookingRef: data.externalBookingRef ?? null,
+                    communicationLanguage: data.communicationLanguage ?? null,
+                    sellCurrency: data.sellCurrency,
+                    baseCurrency: data.baseCurrency ?? null,
+                    sellAmountCents: data.sellAmountCents ?? null,
+                    baseSellAmountCents: data.baseSellAmountCents ?? null,
+                    costAmountCents: data.costAmountCents ?? null,
+                    baseCostAmountCents: data.baseCostAmountCents ?? null,
+                    marginPercent: data.marginPercent ?? null,
+                    startDate: data.startDate ?? null,
+                    endDate: data.endDate ?? null,
+                    pax: data.pax ?? null,
+                    internalNotes: data.internalNotes ?? null,
+                    holdExpiresAt,
+                })
+                    .returning();
+                if (!booking) {
+                    throw new BookingServiceError("booking_create_failed");
+                }
+                for (const item of data.items) {
+                    const capacity = await adjustSlotCapacity(tx, item.availabilitySlotId, -item.quantity);
+                    if (capacity.status === "slot_not_found") {
+                        throw new BookingServiceError("slot_not_found");
+                    }
+                    if (capacity.status === "slot_unavailable") {
+                        throw new BookingServiceError("slot_unavailable");
+                    }
+                    if (capacity.status === "insufficient_capacity") {
+                        throw new BookingServiceError("insufficient_capacity");
+                    }
+                    const slot = capacity.slot;
+                    if (item.productId && item.productId !== slot.product_id) {
+                        throw new BookingServiceError("slot_product_mismatch");
+                    }
+                    if (item.optionId && item.optionId !== slot.option_id) {
+                        throw new BookingServiceError("slot_option_mismatch");
+                    }
+                    const [bookingItem] = await tx
+                        .insert(bookingItems)
+                        .values({
+                        bookingId: booking.id,
+                        title: item.title,
+                        description: item.description ?? null,
+                        itemType: item.itemType,
+                        status: "on_hold",
+                        serviceDate: slot.date_local,
+                        startsAt: slot.starts_at,
+                        endsAt: slot.ends_at,
+                        quantity: item.quantity,
+                        sellCurrency: item.sellCurrency ?? booking.sellCurrency,
+                        unitSellAmountCents: item.unitSellAmountCents ?? null,
+                        totalSellAmountCents: item.totalSellAmountCents ?? null,
+                        costCurrency: item.costCurrency ?? null,
+                        unitCostAmountCents: item.unitCostAmountCents ?? null,
+                        totalCostAmountCents: item.totalCostAmountCents ?? null,
+                        notes: item.notes ?? null,
+                        productId: item.productId ?? slot.product_id,
+                        optionId: item.optionId ?? slot.option_id,
+                        optionUnitId: item.optionUnitId ?? null,
+                        pricingCategoryId: item.pricingCategoryId ?? null,
+                        sourceSnapshotId: item.sourceSnapshotId ?? null,
+                        sourceOfferId: item.sourceOfferId ?? null,
+                        metadata: item.metadata ?? null,
+                    })
+                        .returning();
+                    if (!bookingItem) {
+                        throw new BookingServiceError("booking_item_create_failed");
+                    }
+                    const [allocation] = await tx
+                        .insert(bookingAllocations)
+                        .values({
+                        bookingId: booking.id,
+                        bookingItemId: bookingItem.id,
+                        productId: item.productId ?? slot.product_id,
+                        optionId: item.optionId ?? slot.option_id,
+                        optionUnitId: item.optionUnitId ?? null,
+                        pricingCategoryId: item.pricingCategoryId ?? null,
+                        availabilitySlotId: item.availabilitySlotId,
+                        quantity: item.quantity,
+                        allocationType: item.allocationType,
+                        status: "held",
+                        holdExpiresAt,
+                        metadata: item.metadata ?? null,
+                    })
+                        .returning();
+                    if (!allocation) {
+                        throw new BookingServiceError("allocation_create_failed");
+                    }
+                }
+                await tx.insert(bookingActivityLog).values({
+                    bookingId: booking.id,
+                    actorId: userId ?? "system",
+                    activityType: "booking_reserved",
+                    description: `Booking ${booking.bookingNumber} reserved and placed on hold`,
+                    metadata: { holdExpiresAt: holdExpiresAt.toISOString(), itemCount: data.items.length },
+                });
+                return { status: "ok", booking };
+            });
+        }
+        catch (error) {
+            if (error instanceof BookingServiceError) {
+                return { status: error.code };
+            }
+            throw error;
+        }
+    },
+    async createBooking(db, data, userId) {
+        return db.transaction(async (tx) => {
+            const [row] = await tx
+                .insert(bookings)
+                .values({
+                ...data,
+                holdExpiresAt: toTimestamp(data.holdExpiresAt),
+                confirmedAt: toTimestamp(data.confirmedAt),
+                expiredAt: toTimestamp(data.expiredAt),
+                cancelledAt: toTimestamp(data.cancelledAt),
+                completedAt: toTimestamp(data.completedAt),
+                redeemedAt: toTimestamp(data.redeemedAt),
+            })
+                .returning();
+            if (!row) {
+                return null;
+            }
+            await tx.insert(bookingActivityLog).values({
+                bookingId: row.id,
+                actorId: userId ?? "system",
+                activityType: "booking_created",
+                description: `Booking ${data.bookingNumber} created`,
+            });
+            return row;
+        });
+    },
+    async updateBooking(db, id, data) {
+        const [row] = await db
+            .update(bookings)
+            .set({
+            ...data,
+            holdExpiresAt: data.holdExpiresAt === undefined ? undefined : toTimestamp(data.holdExpiresAt),
+            confirmedAt: data.confirmedAt === undefined ? undefined : toTimestamp(data.confirmedAt),
+            expiredAt: data.expiredAt === undefined ? undefined : toTimestamp(data.expiredAt),
+            cancelledAt: data.cancelledAt === undefined ? undefined : toTimestamp(data.cancelledAt),
+            completedAt: data.completedAt === undefined ? undefined : toTimestamp(data.completedAt),
+            redeemedAt: data.redeemedAt === undefined ? undefined : toTimestamp(data.redeemedAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(bookings.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteBooking(db, id) {
+        const [row] = await db
+            .delete(bookings)
+            .where(eq(bookings.id, id))
+            .returning({ id: bookings.id });
+        return row ?? null;
+    },
+    async updateBookingStatus(db, id, data, userId) {
+        const [current] = await db
+            .select({ id: bookings.id, status: bookings.status })
+            .from(bookings)
+            .where(eq(bookings.id, id))
+            .limit(1);
+        if (!current) {
+            return { status: "not_found" };
+        }
+        if (current.status === "on_hold" && data.status === "confirmed") {
+            return bookingsService.confirmBooking(db, id, { note: data.note }, userId);
+        }
+        if (current.status === "on_hold" && data.status === "expired") {
+            return bookingsService.expireBooking(db, id, { note: data.note }, userId);
+        }
+        if (data.status === "cancelled") {
+            return bookingsService.cancelBooking(db, id, { note: data.note }, userId);
+        }
+        if (data.status === "on_hold") {
+            return { status: "invalid_transition" };
+        }
+        if (!isValidBookingTransition(current.status, data.status)) {
+            return { status: "invalid_transition" };
+        }
+        const [row] = await db
+            .update(bookings)
+            .set({
+            status: data.status,
+            ...toBookingStatusTimestamps(data.status),
+            updatedAt: new Date(),
+        })
+            .where(eq(bookings.id, id))
+            .returning();
+        await db.insert(bookingActivityLog).values({
+            bookingId: id,
+            actorId: userId ?? "system",
+            activityType: "status_change",
+            description: `Status changed from ${current.status} to ${data.status}`,
+            metadata: { oldStatus: current.status, newStatus: data.status },
+        });
+        if (data.note) {
+            await db.insert(bookingNotes).values({
+                bookingId: id,
+                authorId: userId ?? "system",
+                content: data.note,
+            });
+        }
+        if (data.status === "confirmed") {
+            await autoIssueFulfillmentsForBooking(db, id, userId);
+        }
+        return { status: "ok", booking: row ?? null };
+    },
+    async confirmBooking(db, id, data, userId) {
+        try {
+            return await db.transaction(async (tx) => {
+                const rows = await tx.execute(sql `SELECT id, booking_number, status, hold_expires_at
+              FROM ${bookings}
+              WHERE ${bookings.id} = ${id}
+              FOR UPDATE`);
+                const booking = rows[0];
+                if (!booking) {
+                    throw new BookingServiceError("not_found");
+                }
+                if (booking.status !== "on_hold") {
+                    throw new BookingServiceError("invalid_transition");
+                }
+                if (booking.hold_expires_at && booking.hold_expires_at < new Date()) {
+                    throw new BookingServiceError("hold_expired");
+                }
+                await tx
+                    .update(bookingAllocations)
+                    .set({
+                    status: "confirmed",
+                    confirmedAt: new Date(),
+                    updatedAt: new Date(),
+                })
+                    .where(and(eq(bookingAllocations.bookingId, id), eq(bookingAllocations.status, "held")));
+                await tx
+                    .update(bookingItems)
+                    .set({ status: "confirmed", updatedAt: new Date() })
+                    .where(and(eq(bookingItems.bookingId, id), eq(bookingItems.status, "on_hold")));
+                const [row] = await tx
+                    .update(bookings)
+                    .set({
+                    status: "confirmed",
+                    holdExpiresAt: null,
+                    confirmedAt: new Date(),
+                    updatedAt: new Date(),
+                })
+                    .where(eq(bookings.id, id))
+                    .returning();
+                await syncTransactionOnBookingConfirmed(tx, id);
+                await autoIssueFulfillmentsForBooking(tx, id, userId);
+                await tx.insert(bookingActivityLog).values({
+                    bookingId: id,
+                    actorId: userId ?? "system",
+                    activityType: "booking_confirmed",
+                    description: `Booking ${booking.booking_number} confirmed`,
+                });
+                if (data.note) {
+                    await tx.insert(bookingNotes).values({
+                        bookingId: id,
+                        authorId: userId ?? "system",
+                        content: data.note,
+                    });
+                }
+                return { status: "ok", booking: row ?? null };
+            });
+        }
+        catch (error) {
+            if (error instanceof BookingServiceError) {
+                return { status: error.code };
+            }
+            throw error;
+        }
+    },
+    async extendBookingHold(db, id, data, userId) {
+        try {
+            return await db.transaction(async (tx) => {
+                const rows = await tx.execute(sql `SELECT id, status, hold_expires_at
+              FROM ${bookings}
+              WHERE ${bookings.id} = ${id}
+              FOR UPDATE`);
+                const booking = rows[0];
+                if (!booking) {
+                    throw new BookingServiceError("not_found");
+                }
+                if (booking.status !== "on_hold") {
+                    throw new BookingServiceError("invalid_transition");
+                }
+                if (booking.hold_expires_at && booking.hold_expires_at < new Date()) {
+                    throw new BookingServiceError("hold_expired");
+                }
+                const holdExpiresAt = computeHoldExpiresAt(data);
+                await tx
+                    .update(bookingAllocations)
+                    .set({
+                    holdExpiresAt,
+                    updatedAt: new Date(),
+                })
+                    .where(and(eq(bookingAllocations.bookingId, id), eq(bookingAllocations.status, "held")));
+                const [row] = await tx
+                    .update(bookings)
+                    .set({
+                    holdExpiresAt,
+                    updatedAt: new Date(),
+                })
+                    .where(eq(bookings.id, id))
+                    .returning();
+                await tx.insert(bookingActivityLog).values({
+                    bookingId: id,
+                    actorId: userId ?? "system",
+                    activityType: "hold_extended",
+                    description: "Booking hold extended",
+                    metadata: { holdExpiresAt: holdExpiresAt.toISOString() },
+                });
+                return { status: "ok", booking: row ?? null };
+            });
+        }
+        catch (error) {
+            if (error instanceof BookingServiceError) {
+                return { status: error.code };
+            }
+            throw error;
+        }
+    },
+    async expireBooking(db, id, data, userId) {
+        try {
+            return await db.transaction(async (tx) => {
+                const rows = await tx.execute(sql `SELECT id, status, hold_expires_at
+              FROM ${bookings}
+              WHERE ${bookings.id} = ${id}
+              FOR UPDATE`);
+                const booking = rows[0];
+                if (!booking) {
+                    throw new BookingServiceError("not_found");
+                }
+                if (booking.status !== "on_hold") {
+                    throw new BookingServiceError("invalid_transition");
+                }
+                const allocations = await tx
+                    .select()
+                    .from(bookingAllocations)
+                    .where(eq(bookingAllocations.bookingId, id));
+                for (const allocation of allocations) {
+                    await releaseAllocationCapacity(tx, allocation);
+                }
+                await tx
+                    .update(bookingAllocations)
+                    .set({
+                    status: "expired",
+                    releasedAt: new Date(),
+                    updatedAt: new Date(),
+                })
+                    .where(and(eq(bookingAllocations.bookingId, id), eq(bookingAllocations.status, "held")));
+                await tx
+                    .update(bookingItems)
+                    .set({ status: "expired", updatedAt: new Date() })
+                    .where(and(eq(bookingItems.bookingId, id), eq(bookingItems.status, "on_hold")));
+                const [row] = await tx
+                    .update(bookings)
+                    .set({
+                    status: "expired",
+                    holdExpiresAt: null,
+                    expiredAt: new Date(),
+                    updatedAt: new Date(),
+                })
+                    .where(eq(bookings.id, id))
+                    .returning();
+                await syncTransactionOnBookingExpired(tx, id);
+                await tx.insert(bookingActivityLog).values({
+                    bookingId: id,
+                    actorId: userId ?? "system",
+                    activityType: "hold_expired",
+                    description: "Booking hold expired",
+                });
+                if (data.note) {
+                    await tx.insert(bookingNotes).values({
+                        bookingId: id,
+                        authorId: userId ?? "system",
+                        content: data.note,
+                    });
+                }
+                return { status: "ok", booking: row ?? null };
+            });
+        }
+        catch (error) {
+            if (error instanceof BookingServiceError) {
+                return { status: error.code };
+            }
+            throw error;
+        }
+    },
+    async expireStaleBookings(db, data, userId) {
+        const cutoff = data.before ? new Date(data.before) : new Date();
+        const staleBookings = await db
+            .select({ id: bookings.id })
+            .from(bookings)
+            .where(and(eq(bookings.status, "on_hold"), sql `${bookings.holdExpiresAt} IS NOT NULL`, lte(bookings.holdExpiresAt, cutoff)))
+            .orderBy(asc(bookings.holdExpiresAt), asc(bookings.createdAt));
+        const expiredIds = [];
+        for (const booking of staleBookings) {
+            const result = await this.expireBooking(db, booking.id, { note: data.note ?? "Hold expired by sweep" }, userId);
+            if ("booking" in result && result.booking) {
+                expiredIds.push(result.booking.id);
+            }
+        }
+        return {
+            expiredIds,
+            count: expiredIds.length,
+            cutoff,
+        };
+    },
+    async cancelBooking(db, id, data, userId) {
+        try {
+            return await db.transaction(async (tx) => {
+                const rows = await tx.execute(sql `SELECT id, status
+              FROM ${bookings}
+              WHERE ${bookings.id} = ${id}
+              FOR UPDATE`);
+                const booking = rows[0];
+                if (!booking) {
+                    throw new BookingServiceError("not_found");
+                }
+                if (!["draft", "on_hold", "confirmed", "in_progress"].includes(booking.status)) {
+                    throw new BookingServiceError("invalid_transition");
+                }
+                const allocations = await tx
+                    .select()
+                    .from(bookingAllocations)
+                    .where(eq(bookingAllocations.bookingId, id));
+                for (const allocation of allocations) {
+                    await releaseAllocationCapacity(tx, allocation);
+                }
+                await tx
+                    .update(bookingAllocations)
+                    .set({
+                    status: "cancelled",
+                    releasedAt: new Date(),
+                    updatedAt: new Date(),
+                })
+                    .where(and(eq(bookingAllocations.bookingId, id), or(eq(bookingAllocations.status, "held"), eq(bookingAllocations.status, "confirmed"))));
+                await tx
+                    .update(bookingItems)
+                    .set({
+                    status: "cancelled",
+                    updatedAt: new Date(),
+                })
+                    .where(and(eq(bookingItems.bookingId, id), or(eq(bookingItems.status, "draft"), eq(bookingItems.status, "on_hold"), eq(bookingItems.status, "confirmed"))));
+                const [row] = await tx
+                    .update(bookings)
+                    .set({
+                    status: "cancelled",
+                    holdExpiresAt: null,
+                    cancelledAt: new Date(),
+                    updatedAt: new Date(),
+                })
+                    .where(eq(bookings.id, id))
+                    .returning();
+                await syncTransactionOnBookingCancelled(tx, id);
+                await tx.insert(bookingActivityLog).values({
+                    bookingId: id,
+                    actorId: userId ?? "system",
+                    activityType: "status_change",
+                    description: `Booking cancelled from ${booking.status}`,
+                    metadata: { oldStatus: booking.status, newStatus: "cancelled" },
+                });
+                if (data.note) {
+                    await tx.insert(bookingNotes).values({
+                        bookingId: id,
+                        authorId: userId ?? "system",
+                        content: data.note,
+                    });
+                }
+                return { status: "ok", booking: row ?? null };
+            });
+        }
+        catch (error) {
+            if (error instanceof BookingServiceError) {
+                return { status: error.code };
+            }
+            throw error;
+        }
+    },
+    listParticipants(db, bookingId) {
+        return db
+            .select()
+            .from(bookingParticipants)
+            .where(eq(bookingParticipants.bookingId, bookingId))
+            .orderBy(desc(bookingParticipants.isPrimary), asc(bookingParticipants.createdAt));
+    },
+    async getParticipantById(db, bookingId, participantId) {
+        const [row] = await db
+            .select()
+            .from(bookingParticipants)
+            .where(and(eq(bookingParticipants.id, participantId), eq(bookingParticipants.bookingId, bookingId)))
+            .limit(1);
+        return row ?? null;
+    },
+    async createParticipant(db, bookingId, data, userId) {
+        const [booking] = await db
+            .select({ id: bookings.id })
+            .from(bookings)
+            .where(eq(bookings.id, bookingId))
+            .limit(1);
+        if (!booking) {
+            return null;
+        }
+        const [row] = await db
+            .insert(bookingParticipants)
+            .values({
+            bookingId,
+            personId: data.personId ?? null,
+            participantType: data.participantType,
+            travelerCategory: data.travelerCategory ?? null,
+            firstName: data.firstName,
+            lastName: data.lastName,
+            email: data.email ?? null,
+            phone: data.phone ?? null,
+            preferredLanguage: data.preferredLanguage ?? null,
+            accessibilityNeeds: data.accessibilityNeeds ?? null,
+            specialRequests: data.specialRequests ?? null,
+            isPrimary: data.isPrimary ?? false,
+            notes: data.notes ?? null,
+        })
+            .returning();
+        if (!row) {
+            return null;
+        }
+        await ensureParticipantFlags(db, bookingId, row.id, data);
+        await db.insert(bookingActivityLog).values({
+            bookingId,
+            actorId: userId ?? "system",
+            activityType: "passenger_update",
+            description: `Participant ${data.firstName} ${data.lastName} added`,
+            metadata: { participantId: row.id, participantType: data.participantType },
+        });
+        return row;
+    },
+    async updateParticipant(db, participantId, data) {
+        const [row] = await db
+            .update(bookingParticipants)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(bookingParticipants.id, participantId))
+            .returning();
+        if (!row) {
+            return null;
+        }
+        await ensureParticipantFlags(db, row.bookingId, row.id, data);
+        return row;
+    },
+    async deleteParticipant(db, participantId) {
+        const [row] = await db
+            .delete(bookingParticipants)
+            .where(eq(bookingParticipants.id, participantId))
+            .returning({ id: bookingParticipants.id });
+        return row ?? null;
+    },
+    listPassengers(db, bookingId) {
+        return db
+            .select()
+            .from(bookingParticipants)
+            .where(and(eq(bookingParticipants.bookingId, bookingId), or(...travelerParticipantTypes.map((type) => eq(bookingParticipants.participantType, type)))))
+            .orderBy(asc(bookingParticipants.createdAt))
+            .then((rows) => rows.map(toPassengerResponse));
+    },
+    async createPassenger(db, bookingId, data, userId) {
+        const row = await this.createParticipant(db, bookingId, toCreateParticipantFromPassenger(data), userId);
+        return row ? toPassengerResponse(row) : null;
+    },
+    async updatePassenger(db, passengerId, data) {
+        const row = await this.updateParticipant(db, passengerId, toUpdateParticipantFromPassenger(data));
+        return row ? toPassengerResponse(row) : null;
+    },
+    async deletePassenger(db, passengerId) {
+        return this.deleteParticipant(db, passengerId);
+    },
+    listItems(db, bookingId) {
+        return db
+            .select()
+            .from(bookingItems)
+            .where(eq(bookingItems.bookingId, bookingId))
+            .orderBy(asc(bookingItems.createdAt));
+    },
+    async createItem(db, bookingId, data, userId) {
+        const [booking] = await db
+            .select({ id: bookings.id, sellCurrency: bookings.sellCurrency })
+            .from(bookings)
+            .where(eq(bookings.id, bookingId))
+            .limit(1);
+        if (!booking) {
+            return null;
+        }
+        const [row] = await db
+            .insert(bookingItems)
+            .values({
+            bookingId,
+            title: data.title,
+            description: data.description ?? null,
+            itemType: data.itemType,
+            status: data.status,
+            serviceDate: data.serviceDate ?? null,
+            startsAt: toTimestamp(data.startsAt),
+            endsAt: toTimestamp(data.endsAt),
+            quantity: data.quantity,
+            sellCurrency: data.sellCurrency ?? booking.sellCurrency,
+            unitSellAmountCents: data.unitSellAmountCents ?? null,
+            totalSellAmountCents: data.totalSellAmountCents ?? null,
+            costCurrency: data.costCurrency ?? null,
+            unitCostAmountCents: data.unitCostAmountCents ?? null,
+            totalCostAmountCents: data.totalCostAmountCents ?? null,
+            notes: data.notes ?? null,
+            productId: data.productId ?? null,
+            optionId: data.optionId ?? null,
+            optionUnitId: data.optionUnitId ?? null,
+            pricingCategoryId: data.pricingCategoryId ?? null,
+            sourceSnapshotId: data.sourceSnapshotId ?? null,
+            sourceOfferId: data.sourceOfferId ?? null,
+            metadata: data.metadata ?? null,
+        })
+            .returning();
+        if (!row) {
+            return null;
+        }
+        await db.insert(bookingActivityLog).values({
+            bookingId,
+            actorId: userId ?? "system",
+            activityType: "item_update",
+            description: `Booking item "${data.title}" added`,
+            metadata: { bookingItemId: row.id, itemType: data.itemType },
+        });
+        return row;
+    },
+    async updateItem(db, itemId, data) {
+        const [row] = await db
+            .update(bookingItems)
+            .set({
+            ...data,
+            startsAt: data.startsAt === undefined ? undefined : toTimestamp(data.startsAt),
+            endsAt: data.endsAt === undefined ? undefined : toTimestamp(data.endsAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(bookingItems.id, itemId))
+            .returning();
+        return row ?? null;
+    },
+    async deleteItem(db, itemId) {
+        const [row] = await db
+            .delete(bookingItems)
+            .where(eq(bookingItems.id, itemId))
+            .returning({ id: bookingItems.id });
+        return row ?? null;
+    },
+    listItemParticipants(db, itemId) {
+        return db
+            .select()
+            .from(bookingItemParticipants)
+            .where(eq(bookingItemParticipants.bookingItemId, itemId))
+            .orderBy(desc(bookingItemParticipants.isPrimary), asc(bookingItemParticipants.createdAt));
+    },
+    async addItemParticipant(db, itemId, data) {
+        const [item] = await db
+            .select({ id: bookingItems.id })
+            .from(bookingItems)
+            .where(eq(bookingItems.id, itemId))
+            .limit(1);
+        if (!item) {
+            return null;
+        }
+        const [participant] = await db
+            .select({ id: bookingParticipants.id })
+            .from(bookingParticipants)
+            .where(eq(bookingParticipants.id, data.participantId))
+            .limit(1);
+        if (!participant) {
+            return null;
+        }
+        if (data.isPrimary) {
+            await db
+                .update(bookingItemParticipants)
+                .set({ isPrimary: false })
+                .where(eq(bookingItemParticipants.bookingItemId, itemId));
+        }
+        const [row] = await db
+            .insert(bookingItemParticipants)
+            .values({
+            bookingItemId: itemId,
+            participantId: data.participantId,
+            role: data.role,
+            isPrimary: data.isPrimary ?? false,
+        })
+            .returning();
+        return row;
+    },
+    async removeItemParticipant(db, linkId) {
+        const [row] = await db
+            .delete(bookingItemParticipants)
+            .where(eq(bookingItemParticipants.id, linkId))
+            .returning({ id: bookingItemParticipants.id });
+        return row ?? null;
+    },
+    listSupplierStatuses(db, bookingId) {
+        return db
+            .select()
+            .from(bookingSupplierStatuses)
+            .where(eq(bookingSupplierStatuses.bookingId, bookingId))
+            .orderBy(asc(bookingSupplierStatuses.createdAt));
+    },
+    async createSupplierStatus(db, bookingId, data, userId) {
+        const [booking] = await db
+            .select({ id: bookings.id })
+            .from(bookings)
+            .where(eq(bookings.id, bookingId))
+            .limit(1);
+        if (!booking) {
+            return null;
+        }
+        const [row] = await db
+            .insert(bookingSupplierStatuses)
+            .values({
+            bookingId,
+            supplierServiceId: data.supplierServiceId ?? null,
+            serviceName: data.serviceName,
+            status: data.status ?? "pending",
+            supplierReference: data.supplierReference ?? null,
+            costCurrency: data.costCurrency,
+            costAmountCents: data.costAmountCents,
+            notes: data.notes ?? null,
+            confirmedAt: data.status === "confirmed" ? new Date() : null,
+        })
+            .returning();
+        await db.insert(bookingActivityLog).values({
+            bookingId,
+            actorId: userId ?? "system",
+            activityType: "supplier_update",
+            description: `Supplier status for "${data.serviceName}" added`,
+        });
+        return row ?? null;
+    },
+    async updateSupplierStatus(db, bookingId, statusId, data, userId) {
+        const updateData = {
+            ...data,
+            supplierServiceId: data.supplierServiceId ?? undefined,
+            supplierReference: data.supplierReference ?? undefined,
+            confirmedAt: data.confirmedAt !== undefined
+                ? toTimestamp(data.confirmedAt)
+                : data.status === "confirmed"
+                    ? new Date()
+                    : undefined,
+            updatedAt: new Date(),
+        };
+        const [row] = await db
+            .update(bookingSupplierStatuses)
+            .set(updateData)
+            .where(eq(bookingSupplierStatuses.id, statusId))
+            .returning();
+        if (!row) {
+            return null;
+        }
+        if (data.status) {
+            await db.insert(bookingActivityLog).values({
+                bookingId,
+                actorId: userId ?? "system",
+                activityType: "supplier_update",
+                description: `Supplier "${row.serviceName}" status updated to ${data.status}`,
+                metadata: { supplierStatusId: statusId, newStatus: data.status },
+            });
+        }
+        return row;
+    },
+    listFulfillments(db, bookingId) {
+        return db
+            .select()
+            .from(bookingFulfillments)
+            .where(eq(bookingFulfillments.bookingId, bookingId))
+            .orderBy(desc(bookingFulfillments.createdAt));
+    },
+    async issueFulfillment(db, bookingId, data, userId) {
+        const [booking] = await db
+            .select({ id: bookings.id })
+            .from(bookings)
+            .where(eq(bookings.id, bookingId))
+            .limit(1);
+        if (!booking) {
+            return null;
+        }
+        const scoped = await ensureBookingScopedLinks(db, bookingId, data);
+        if (!scoped.ok) {
+            return null;
+        }
+        const status = data.status ?? "issued";
+        const issuedAt = data.issuedAt !== undefined
+            ? toTimestamp(data.issuedAt)
+            : status === "issued" || status === "reissued"
+                ? new Date()
+                : null;
+        const revokedAt = data.revokedAt !== undefined
+            ? toTimestamp(data.revokedAt)
+            : status === "revoked"
+                ? new Date()
+                : null;
+        const [row] = await db
+            .insert(bookingFulfillments)
+            .values({
+            bookingId,
+            bookingItemId: data.bookingItemId ?? null,
+            participantId: data.participantId ?? null,
+            fulfillmentType: data.fulfillmentType,
+            deliveryChannel: data.deliveryChannel,
+            status,
+            artifactUrl: data.artifactUrl ?? null,
+            payload: data.payload ?? null,
+            issuedAt,
+            revokedAt,
+        })
+            .returning();
+        await db.insert(bookingActivityLog).values({
+            bookingId,
+            actorId: userId ?? "system",
+            activityType: "fulfillment_issued",
+            description: `Booking fulfillment issued as ${data.fulfillmentType}`,
+            metadata: {
+                fulfillmentId: row?.id ?? null,
+                bookingItemId: data.bookingItemId ?? null,
+                participantId: data.participantId ?? null,
+                status,
+            },
+        });
+        return row ?? null;
+    },
+    async updateFulfillment(db, bookingId, fulfillmentId, data, userId) {
+        const [existing] = await db
+            .select({ id: bookingFulfillments.id })
+            .from(bookingFulfillments)
+            .where(and(eq(bookingFulfillments.id, fulfillmentId), eq(bookingFulfillments.bookingId, bookingId)))
+            .limit(1);
+        if (!existing) {
+            return null;
+        }
+        const scoped = await ensureBookingScopedLinks(db, bookingId, data);
+        if (!scoped.ok) {
+            return null;
+        }
+        const nextStatus = data.status;
+        const [row] = await db
+            .update(bookingFulfillments)
+            .set({
+            bookingItemId: data.bookingItemId === undefined ? undefined : (data.bookingItemId ?? null),
+            participantId: data.participantId === undefined ? undefined : (data.participantId ?? null),
+            fulfillmentType: data.fulfillmentType,
+            deliveryChannel: data.deliveryChannel,
+            status: nextStatus,
+            artifactUrl: data.artifactUrl === undefined ? undefined : (data.artifactUrl ?? null),
+            payload: data.payload === undefined ? undefined : (data.payload ?? null),
+            issuedAt: data.issuedAt !== undefined
+                ? toTimestamp(data.issuedAt)
+                : nextStatus === "issued" || nextStatus === "reissued"
+                    ? new Date()
+                    : undefined,
+            revokedAt: data.revokedAt !== undefined
+                ? toTimestamp(data.revokedAt)
+                : nextStatus === "revoked"
+                    ? new Date()
+                    : undefined,
+            updatedAt: new Date(),
+        })
+            .where(eq(bookingFulfillments.id, fulfillmentId))
+            .returning();
+        if (row) {
+            await db.insert(bookingActivityLog).values({
+                bookingId,
+                actorId: userId ?? "system",
+                activityType: "fulfillment_updated",
+                description: `Booking fulfillment ${fulfillmentId} updated`,
+                metadata: {
+                    fulfillmentId,
+                    bookingItemId: row.bookingItemId,
+                    participantId: row.participantId,
+                    status: row.status,
+                },
+            });
+        }
+        return row ?? null;
+    },
+    listRedemptionEvents(db, bookingId) {
+        return db
+            .select()
+            .from(bookingRedemptionEvents)
+            .where(eq(bookingRedemptionEvents.bookingId, bookingId))
+            .orderBy(desc(bookingRedemptionEvents.redeemedAt), desc(bookingRedemptionEvents.createdAt));
+    },
+    async recordRedemption(db, bookingId, data, userId) {
+        return db.transaction(async (tx) => {
+            const [booking] = await tx
+                .select({
+                id: bookings.id,
+                redeemedAt: bookings.redeemedAt,
+            })
+                .from(bookings)
+                .where(eq(bookings.id, bookingId))
+                .limit(1);
+            if (!booking) {
+                return null;
+            }
+            const scoped = await ensureBookingScopedLinks(tx, bookingId, data);
+            if (!scoped.ok) {
+                return null;
+            }
+            const redeemedAt = toTimestamp(data.redeemedAt) ?? new Date();
+            const [event] = await tx
+                .insert(bookingRedemptionEvents)
+                .values({
+                bookingId,
+                bookingItemId: data.bookingItemId ?? null,
+                participantId: data.participantId ?? null,
+                redeemedAt,
+                redeemedBy: data.redeemedBy ?? userId ?? null,
+                location: data.location ?? null,
+                method: data.method,
+                metadata: data.metadata ?? null,
+            })
+                .returning();
+            if (!booking.redeemedAt || booking.redeemedAt < redeemedAt) {
+                await tx
+                    .update(bookings)
+                    .set({
+                    redeemedAt,
+                    updatedAt: new Date(),
+                })
+                    .where(eq(bookings.id, bookingId));
+            }
+            if (data.bookingItemId) {
+                await tx
+                    .update(bookingItems)
+                    .set({
+                    status: "fulfilled",
+                    updatedAt: new Date(),
+                })
+                    .where(and(eq(bookingItems.id, data.bookingItemId), eq(bookingItems.bookingId, bookingId), or(eq(bookingItems.status, "confirmed"), eq(bookingItems.status, "on_hold"), eq(bookingItems.status, "draft"))));
+                await tx
+                    .update(bookingAllocations)
+                    .set({
+                    status: "fulfilled",
+                    updatedAt: new Date(),
+                })
+                    .where(and(eq(bookingAllocations.bookingId, bookingId), eq(bookingAllocations.bookingItemId, data.bookingItemId), or(eq(bookingAllocations.status, "held"), eq(bookingAllocations.status, "confirmed"))));
+            }
+            await tx.insert(bookingActivityLog).values({
+                bookingId,
+                actorId: userId ?? "system",
+                activityType: "redemption_recorded",
+                description: "Booking redemption recorded",
+                metadata: {
+                    redemptionEventId: event?.id ?? null,
+                    bookingItemId: data.bookingItemId ?? null,
+                    participantId: data.participantId ?? null,
+                    redeemedAt: redeemedAt.toISOString(),
+                    method: data.method,
+                },
+            });
+            await syncTransactionOnBookingRedeemed(tx, bookingId);
+            return event ?? null;
+        });
+    },
+    listActivity(db, bookingId) {
+        return db
+            .select()
+            .from(bookingActivityLog)
+            .where(eq(bookingActivityLog.bookingId, bookingId))
+            .orderBy(desc(bookingActivityLog.createdAt));
+    },
+    listNotes(db, bookingId) {
+        return db
+            .select()
+            .from(bookingNotes)
+            .where(eq(bookingNotes.bookingId, bookingId))
+            .orderBy(bookingNotes.createdAt);
+    },
+    async createNote(db, bookingId, userId, data) {
+        const [booking] = await db
+            .select({ id: bookings.id })
+            .from(bookings)
+            .where(eq(bookings.id, bookingId))
+            .limit(1);
+        if (!booking) {
+            return null;
+        }
+        const [row] = await db
+            .insert(bookingNotes)
+            .values({
+            bookingId,
+            authorId: userId,
+            content: data.content,
+        })
+            .returning();
+        await db.insert(bookingActivityLog).values({
+            bookingId,
+            actorId: userId,
+            activityType: "note_added",
+            description: "Note added",
+        });
+        return row;
+    },
+    listDocuments(db, bookingId) {
+        return db
+            .select()
+            .from(bookingDocuments)
+            .where(eq(bookingDocuments.bookingId, bookingId))
+            .orderBy(bookingDocuments.createdAt);
+    },
+    async createDocument(db, bookingId, data) {
+        const [booking] = await db
+            .select({ id: bookings.id })
+            .from(bookings)
+            .where(eq(bookings.id, bookingId))
+            .limit(1);
+        if (!booking) {
+            return null;
+        }
+        const [row] = await db
+            .insert(bookingDocuments)
+            .values({
+            bookingId,
+            participantId: data.participantId ?? data.passengerId ?? null,
+            type: data.type,
+            fileName: data.fileName,
+            fileUrl: data.fileUrl,
+            expiresAt: data.expiresAt ? new Date(data.expiresAt) : null,
+            notes: data.notes ?? null,
+        })
+            .returning();
+        return row;
+    },
+    async deleteDocument(db, documentId) {
+        const [row] = await db
+            .delete(bookingDocuments)
+            .where(eq(bookingDocuments.id, documentId))
+            .returning({ id: bookingDocuments.id });
+        return row ?? null;
+    },
+};