@voyantjs/bookings 0.119.1 → 0.119.3

package/dist/service-public.js

@@ -1,1175 +1 @@
-import { and, asc, desc, eq, inArray, or } from "drizzle-orm";
-import { departurePriceOverridesRef, optionPriceRulesRef, optionUnitPriceRulesRef, optionUnitTiersRef, priceCatalogsRef, pricingCategoriesRef, } from "./pricing-ref.js";
-import { optionUnitsRef, productOptionsRef, productsRef } from "./products-ref.js";
-import { bookingAllocations, bookingDocuments, bookingFulfillments, bookingItems, bookingItemTravelers, bookingSessionStates, bookings, bookingTravelers, } from "./schema.js";
-import { bookingsService } from "./service.js";
-import { publicBookingSessionTravelerInputSchema } from "./validation-public.js";
-const BOOKING_PERSON_SOURCE = "storefront-booking";
-async function safeResolveTravelerPerson(db, resolver, participant, bookingId) {
-    if (!resolver)
-        return null;
-    const contact = {
-        firstName: participant.firstName,
-        lastName: participant.lastName,
-        email: participant.email,
-        phone: participant.phone,
-        preferredLanguage: participant.preferredLanguage,
-    };
-    try {
-        return await resolver(db, contact, {
-            bookingId,
-            source: BOOKING_PERSON_SOURCE,
-            sourceRef: bookingId,
-        });
-    }
-    catch (error) {
-        // Person resolution is best-effort — a CRM hiccup must not block
-        // the actual booking. Log and fall back to `null` so the traveler
-        // row still lands without a person link.
-        console.error("[bookings] resolveTravelerPerson failed for booking", bookingId, error);
-        return null;
-    }
-}
-async function safeResolveBillingPerson(db, resolver, contact, bookingId) {
-    if (!resolver)
-        return null;
-    try {
-        return await resolver(db, contact, {
-            bookingId,
-            source: BOOKING_PERSON_SOURCE,
-            sourceRef: bookingId,
-        });
-    }
-    catch (error) {
-        console.error("[bookings] resolveBillingPerson failed for booking", bookingId, error);
-        return null;
-    }
-}
-const travelerParticipantTypeValues = ["traveler", "occupant"];
-const travelerParticipantTypes = new Set(travelerParticipantTypeValues);
-const WIZARD_STATE_KEY = "wizard";
-function normalizeDate(value) {
-    if (!value) {
-        return null;
-    }
-    if (value instanceof Date) {
-        return value.toISOString().slice(0, 10);
-    }
-    return value;
-}
-function normalizeDateTime(value) {
-    if (!value) {
-        return null;
-    }
-    return value instanceof Date ? value.toISOString() : value;
-}
-function getRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function getNestedRecord(record, keys) {
-    for (const key of keys) {
-        const value = getRecord(record?.[key]);
-        if (value) {
-            return value;
-        }
-    }
-    return null;
-}
-function getRecordString(record, keys) {
-    for (const key of keys) {
-        const value = record?.[key];
-        if (typeof value === "string" && value.length > 0) {
-            return value;
-        }
-    }
-    return null;
-}
-function getBillingPartyType(record) {
-    const value = getRecordString(record, ["partyType", "type"]);
-    return value === "individual" || value === "company" ? value : null;
-}
-function getArray(value) {
-    return Array.isArray(value) ? value : null;
-}
-function extractBookingContactFromStatePayload(payload) {
-    const root = getRecord(payload);
-    const stepData = getNestedRecord(root, ["stepData", "steps"]);
-    const billingRecord = getNestedRecord(root, ["billing", "billingContact", "contact"]) ??
-        getNestedRecord(stepData, ["billing", "billingContact", "contact"]);
-    const billing = getNestedRecord(billingRecord, ["billing", "contact"]) ?? billingRecord;
-    if (!billing) {
-        return null;
-    }
-    return {
-        contactFirstName: getRecordString(billing, ["firstName"]),
-        contactLastName: getRecordString(billing, ["lastName"]),
-        contactPartyType: getBillingPartyType(billing),
-        contactTaxId: getRecordString(billing, ["taxId", "vatNumber", "vatId"]),
-        contactEmail: getRecordString(billing, ["email"]),
-        contactPhone: getRecordString(billing, ["phone"]),
-        contactCountry: getRecordString(billing, ["country"]),
-        contactRegion: getRecordString(billing, ["state", "region"]),
-        contactCity: getRecordString(billing, ["city"]),
-        contactAddressLine1: getRecordString(billing, ["addressLine1", "address1", "line1"]),
-        contactAddressLine2: getRecordString(billing, ["addressLine2", "address2", "line2"]),
-        contactPostalCode: getRecordString(billing, ["postalCode", "postal", "zip"]),
-    };
-}
-function extractBookingTravelersFromStatePayload(payload) {
-    const root = getRecord(payload);
-    const stepData = getNestedRecord(root, ["stepData", "steps"]);
-    const travelersRecord = getNestedRecord(root, ["travelers"]) ?? getNestedRecord(stepData, ["travelers"]);
-    const travelers = getArray(travelersRecord?.travelers) ??
-        getArray(root?.travelers) ??
-        getArray(stepData?.travelers);
-    if (!travelers) {
-        return null;
-    }
-    const parsed = publicBookingSessionTravelerInputSchema.array().safeParse(travelers);
-    return parsed.success ? parsed.data : null;
-}
-function countTravelerParticipants(participants) {
-    return participants.filter((participant) => travelerParticipantTypes.has(participant.participantType)).length;
-}
-async function resolveTravelerPersonForParticipant(db, resolver, participant, bookingId, existingPersonId) {
-    if (existingPersonId) {
-        return existingPersonId;
-    }
-    return safeResolveTravelerPerson(db, resolver, {
-        firstName: participant.firstName,
-        lastName: participant.lastName,
-        email: participant.email ?? null,
-        phone: participant.phone ?? null,
-        preferredLanguage: participant.preferredLanguage ?? null,
-    }, bookingId);
-}
-async function syncTravelerRowsFromStatePayload(db, bookingId, payload, resolvers, userId) {
-    const travelers = extractBookingTravelersFromStatePayload(payload);
-    if (!travelers) {
-        return;
-    }
-    const existingTravelers = await db
-        .select()
-        .from(bookingTravelers)
-        .where(and(eq(bookingTravelers.bookingId, bookingId), inArray(bookingTravelers.participantType, [...travelerParticipantTypeValues])))
-        .orderBy(asc(bookingTravelers.createdAt));
-    const existingById = new Map(existingTravelers.map((traveler) => [traveler.id, traveler]));
-    const usedExistingIds = new Set();
-    for (const participant of travelers) {
-        const matchingExisting = (participant.id ? existingById.get(participant.id) : undefined) ??
-            (participant.id
-                ? undefined
-                : existingTravelers.find((traveler) => !usedExistingIds.has(traveler.id)));
-        const hasStableContactPoint = Boolean(participant.email?.trim() || participant.phone?.trim());
-        const reusablePersonId = participant.id || !hasStableContactPoint ? (matchingExisting?.personId ?? null) : null;
-        const personId = await resolveTravelerPersonForParticipant(db, resolvers.resolveTravelerPerson, participant, bookingId, reusablePersonId);
-        const travelerRecord = {
-            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,
-            specialRequests: participant.specialRequests ?? null,
-            isPrimary: participant.isPrimary,
-            notes: participant.notes ?? null,
-            personId,
-        };
-        if (matchingExisting) {
-            await bookingsService.updateTravelerRecord(db, matchingExisting.id, travelerRecord);
-            usedExistingIds.add(matchingExisting.id);
-            continue;
-        }
-        const created = await bookingsService.createTravelerRecord(db, bookingId, travelerRecord, userId);
-        if (created) {
-            usedExistingIds.add(created.id);
-        }
-    }
-    for (const existing of existingTravelers) {
-        if (!usedExistingIds.has(existing.id)) {
-            await bookingsService.deleteTravelerRecord(db, existing.id);
-        }
-    }
-    const travelerCount = countTravelerParticipants(travelers);
-    await bookingsService.updateBooking(db, bookingId, {
-        pax: travelerCount > 0 ? travelerCount : null,
-    });
-}
-function normalizeSessionState(bookingId, state) {
-    if (!state) {
-        return null;
-    }
-    return {
-        sessionId: bookingId,
-        stateKey: WIZARD_STATE_KEY,
-        currentStep: state.currentStep ?? null,
-        completedSteps: state.completedSteps ?? [],
-        payload: state.payload ?? {},
-        version: state.version,
-        createdAt: normalizeDateTime(state.createdAt),
-        updatedAt: normalizeDateTime(state.updatedAt),
-    };
-}
-async function getWizardSessionState(db, bookingId) {
-    const [state] = await db
-        .select()
-        .from(bookingSessionStates)
-        .where(and(eq(bookingSessionStates.bookingId, bookingId), eq(bookingSessionStates.stateKey, WIZARD_STATE_KEY)))
-        .limit(1);
-    return normalizeSessionState(bookingId, state);
-}
-async function upsertWizardSessionState(db, bookingId, input) {
-    const [existing] = await db
-        .select()
-        .from(bookingSessionStates)
-        .where(and(eq(bookingSessionStates.bookingId, bookingId), eq(bookingSessionStates.stateKey, WIZARD_STATE_KEY)))
-        .limit(1);
-    const payload = input.replacePayload
-        ? input.payload
-        : {
-            ...(existing?.payload ?? {}),
-            ...input.payload,
-        };
-    const completedSteps = input.completedSteps ?? existing?.completedSteps ?? [];
-    const currentStep = input.currentStep === undefined ? (existing?.currentStep ?? null) : (input.currentStep ?? null);
-    if (existing) {
-        const [updated] = await db
-            .update(bookingSessionStates)
-            .set({
-            currentStep,
-            completedSteps,
-            payload,
-            version: existing.version + 1,
-            updatedAt: new Date(),
-        })
-            .where(eq(bookingSessionStates.id, existing.id))
-            .returning();
-        return normalizeSessionState(bookingId, updated ?? existing);
-    }
-    const [created] = await db
-        .insert(bookingSessionStates)
-        .values({
-        bookingId,
-        stateKey: WIZARD_STATE_KEY,
-        currentStep,
-        completedSteps,
-        payload,
-        version: 1,
-    })
-        .returning();
-    return normalizeSessionState(bookingId, created);
-}
-function resolveTierAmount(tiers, quantity, fallbackAmount) {
-    const tier = tiers.find((candidate) => quantity >= candidate.minQuantity &&
-        (candidate.maxQuantity === null || quantity <= candidate.maxQuantity));
-    return tier?.sellAmountCents ?? fallbackAmount;
-}
-function computeLineTotal(pricingMode, unitSellAmountCents, quantity, fallbackAmount) {
-    switch (pricingMode) {
-        case "free":
-        case "included":
-            return 0;
-        case "on_request":
-            return null;
-        case "per_unit":
-        case "per_person":
-            return unitSellAmountCents === null ? null : unitSellAmountCents * quantity;
-        default:
-            return unitSellAmountCents ?? fallbackAmount;
-    }
-}
-async function generateBookingNumber(db) {
-    const now = new Date();
-    const y = now.getFullYear().toString().slice(-2);
-    const m = String(now.getMonth() + 1).padStart(2, "0");
-    for (let attempt = 0; attempt < 10; attempt += 1) {
-        const suffix = String(Math.floor(Math.random() * 900000) + 100000);
-        const bookingNumber = `BK-${y}${m}-${suffix}`;
-        const [existing] = await db
-            .select({ id: bookings.id })
-            .from(bookings)
-            .where(eq(bookings.bookingNumber, bookingNumber))
-            .limit(1);
-        if (!existing) {
-            return bookingNumber;
-        }
-    }
-    throw new Error("Unable to generate a unique booking number");
-}
-async function buildOverviewSnapshot(db, query) {
-    const bookingLookupNumber = query.bookingNumber ?? query.bookingCode ?? null;
-    const [booking] = await db
-        .select()
-        .from(bookings)
-        .where(query.bookingId
-        ? eq(bookings.id, query.bookingId)
-        : bookingLookupNumber
-            ? eq(bookings.bookingNumber, bookingLookupNumber)
-            : eq(bookings.id, "__missing__"))
-        .limit(1);
-    if (!booking) {
-        return null;
-    }
-    const [participants, items, itemParticipantLinks, documents, fulfillments] = await Promise.all([
-        db
-            .select()
-            .from(bookingTravelers)
-            .where(eq(bookingTravelers.bookingId, booking.id))
-            .orderBy(asc(bookingTravelers.createdAt)),
-        db
-            .select()
-            .from(bookingItems)
-            .where(eq(bookingItems.bookingId, booking.id))
-            .orderBy(asc(bookingItems.createdAt)),
-        db
-            .select({
-            id: bookingItemTravelers.id,
-            bookingItemId: bookingItemTravelers.bookingItemId,
-            travelerId: bookingItemTravelers.travelerId,
-            role: bookingItemTravelers.role,
-            isPrimary: bookingItemTravelers.isPrimary,
-        })
-            .from(bookingItemTravelers)
-            .innerJoin(bookingItems, eq(bookingItems.id, bookingItemTravelers.bookingItemId))
-            .where(eq(bookingItems.bookingId, booking.id))
-            .orderBy(asc(bookingItemTravelers.createdAt)),
-        db
-            .select()
-            .from(bookingDocuments)
-            .where(eq(bookingDocuments.bookingId, booking.id))
-            .orderBy(asc(bookingDocuments.createdAt)),
-        db
-            .select()
-            .from(bookingFulfillments)
-            .where(eq(bookingFulfillments.bookingId, booking.id))
-            .orderBy(asc(bookingFulfillments.createdAt)),
-    ]);
-    const email = query.email?.trim().toLowerCase() ?? null;
-    if (email) {
-        const authorized = participants.some((participant) => constantTimeEqualString(participant.email?.trim().toLowerCase() ?? "", email));
-        if (!authorized) {
-            return null;
-        }
-    }
-    const itemLinksByItemId = new Map();
-    for (const link of itemParticipantLinks) {
-        const existing = itemLinksByItemId.get(link.bookingItemId) ?? [];
-        existing.push({
-            id: link.id,
-            travelerId: link.travelerId,
-            role: link.role,
-            isPrimary: link.isPrimary,
-        });
-        itemLinksByItemId.set(link.bookingItemId, existing);
-    }
-    return {
-        bookingId: booking.id,
-        bookingNumber: booking.bookingNumber,
-        status: booking.status,
-        sellCurrency: booking.sellCurrency,
-        sellAmountCents: booking.sellAmountCents ?? null,
-        startDate: normalizeDate(booking.startDate),
-        endDate: normalizeDate(booking.endDate),
-        pax: booking.pax ?? null,
-        confirmedAt: normalizeDateTime(booking.confirmedAt),
-        cancelledAt: normalizeDateTime(booking.cancelledAt),
-        completedAt: normalizeDateTime(booking.completedAt),
-        travelers: participants.map((participant) => ({
-            id: participant.id,
-            participantType: participant.participantType,
-            firstName: participant.firstName,
-            lastName: participant.lastName,
-            isPrimary: participant.isPrimary,
-        })),
-        items: items.map((item) => ({
-            id: item.id,
-            title: item.title,
-            description: item.description ?? null,
-            itemType: item.itemType,
-            status: item.status,
-            serviceDate: normalizeDate(item.serviceDate),
-            startsAt: normalizeDateTime(item.startsAt),
-            endsAt: normalizeDateTime(item.endsAt),
-            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.optionUnitId ?? null,
-            pricingCategoryId: item.pricingCategoryId ?? null,
-            travelerLinks: itemLinksByItemId.get(item.id) ?? [],
-        })),
-        documents: documents.map((document) => ({
-            id: document.id,
-            travelerId: document.travelerId ?? null,
-            type: document.type,
-            fileName: document.fileName,
-            fileUrl: document.fileUrl,
-        })),
-        fulfillments: fulfillments.map((fulfillment) => ({
-            id: fulfillment.id,
-            bookingItemId: fulfillment.bookingItemId ?? null,
-            travelerId: fulfillment.travelerId ?? null,
-            fulfillmentType: fulfillment.fulfillmentType,
-            deliveryChannel: fulfillment.deliveryChannel,
-            status: fulfillment.status,
-            artifactUrl: fulfillment.artifactUrl ?? null,
-        })),
-    };
-}
-function constantTimeEqualString(left, right) {
-    let result = left.length ^ right.length;
-    const length = Math.max(left.length, right.length);
-    for (let index = 0; index < length; index += 1) {
-        result |= (left.charCodeAt(index) || 0) ^ (right.charCodeAt(index) || 0);
-    }
-    return result === 0;
-}
-function buildUnitWarnings(unit, quantity, sessionPax) {
-    const warnings = [];
-    if (!unit) {
-        return warnings;
-    }
-    if (unit.minQuantity !== null && quantity < unit.minQuantity) {
-        warnings.push(`Selected quantity is below the minimum for ${unit.name}.`);
-    }
-    if (unit.maxQuantity !== null && quantity > unit.maxQuantity) {
-        warnings.push(`Selected quantity is above the maximum for ${unit.name}.`);
-    }
-    if (sessionPax && unit.occupancyMin !== null && quantity * unit.occupancyMin > sessionPax) {
-        warnings.push(`Selected ${unit.name} quantity exceeds the current traveler count.`);
-    }
-    if (sessionPax && unit.occupancyMax !== null && quantity * unit.occupancyMax < sessionPax) {
-        warnings.push(`Selected ${unit.name} quantity does not cover the current traveler count.`);
-    }
-    return warnings;
-}
-/**
- * Resolves the catalog-scoped pricing snapshot for a product (options → option
- * price rules → per-unit price rules → tiers). The snapshot is the same data
- * the storefront booking session uses to compute a total — exposing it as a
- * standalone admin preview lets operator dialogs, tour-sheet exports, and
- * reconciliation flows see the same numbers the customer would see, without
- * creating a throwaway session.
- *
- * Returns `null` when the product isn't publicly visible or there's no active
- * catalog / matching option (caller can decide whether to 404 or surface a
- * "pricing unavailable for this selection" message).
- */
-export async function resolveSessionPricingSnapshot(db, productId, input) {
-    const productConditions = [eq(productsRef.id, productId), eq(productsRef.status, "active")];
-    if (input.requirePublicProduct ?? true) {
-        productConditions.push(eq(productsRef.activated, true), eq(productsRef.visibility, "public"));
-    }
-    const [product] = await db
-        .select({
-        id: productsRef.id,
-    })
-        .from(productsRef)
-        .where(and(...productConditions))
-        .limit(1);
-    if (!product) {
-        return null;
-    }
-    const catalog = input.catalogId
-        ? await db
-            .select({
-            id: priceCatalogsRef.id,
-            currencyCode: priceCatalogsRef.currencyCode,
-        })
-            .from(priceCatalogsRef)
-            .where(and(eq(priceCatalogsRef.id, input.catalogId), eq(priceCatalogsRef.catalogType, "public"), eq(priceCatalogsRef.active, true)))
-            .limit(1)
-            .then((rows) => rows[0] ?? null)
-        : await db
-            .select({
-            id: priceCatalogsRef.id,
-            currencyCode: priceCatalogsRef.currencyCode,
-        })
-            .from(priceCatalogsRef)
-            .where(and(eq(priceCatalogsRef.catalogType, "public"), eq(priceCatalogsRef.active, true)))
-            .orderBy(desc(priceCatalogsRef.isDefault), asc(priceCatalogsRef.name))
-            .limit(1)
-            .then((rows) => rows[0] ?? null);
-    if (!catalog) {
-        return null;
-    }
-    const optionConditions = [
-        eq(productOptionsRef.productId, productId),
-        eq(productOptionsRef.status, "active"),
-    ];
-    if (input.optionId) {
-        optionConditions.push(eq(productOptionsRef.id, input.optionId));
-    }
-    const options = await db
-        .select({
-        id: productOptionsRef.id,
-        name: productOptionsRef.name,
-        isDefault: productOptionsRef.isDefault,
-    })
-        .from(productOptionsRef)
-        .where(and(...optionConditions))
-        .orderBy(desc(productOptionsRef.isDefault), asc(productOptionsRef.sortOrder));
-    if (options.length === 0) {
-        return null;
-    }
-    const optionIds = options.map((option) => option.id);
-    const [rules, unitPrices] = await Promise.all([
-        db
-            .select({
-            id: optionPriceRulesRef.id,
-            optionId: optionPriceRulesRef.optionId,
-            pricingMode: optionPriceRulesRef.pricingMode,
-            baseSellAmountCents: optionPriceRulesRef.baseSellAmountCents,
-            isDefault: optionPriceRulesRef.isDefault,
-        })
-            .from(optionPriceRulesRef)
-            .where(and(eq(optionPriceRulesRef.productId, productId), inArray(optionPriceRulesRef.optionId, optionIds), eq(optionPriceRulesRef.priceCatalogId, catalog.id), eq(optionPriceRulesRef.active, true)))
-            .orderBy(desc(optionPriceRulesRef.isDefault), asc(optionPriceRulesRef.name)),
-        db
-            .select({
-            id: optionUnitPriceRulesRef.id,
-            optionPriceRuleId: optionUnitPriceRulesRef.optionPriceRuleId,
-            optionId: optionUnitPriceRulesRef.optionId,
-            unitId: optionUnitPriceRulesRef.unitId,
-            unitName: optionUnitsRef.name,
-            unitType: optionUnitsRef.unitType,
-            occupancyMax: optionUnitsRef.occupancyMax,
-            pricingCategoryId: optionUnitPriceRulesRef.pricingCategoryId,
-            pricingMode: optionUnitPriceRulesRef.pricingMode,
-            sellAmountCents: optionUnitPriceRulesRef.sellAmountCents,
-            minQuantity: optionUnitPriceRulesRef.minQuantity,
-            maxQuantity: optionUnitPriceRulesRef.maxQuantity,
-        })
-            .from(optionUnitPriceRulesRef)
-            .innerJoin(optionUnitsRef, eq(optionUnitsRef.id, optionUnitPriceRulesRef.unitId))
-            .where(and(inArray(optionUnitPriceRulesRef.optionId, optionIds), eq(optionUnitPriceRulesRef.active, true)))
-            .orderBy(asc(optionUnitPriceRulesRef.sortOrder), asc(optionUnitPriceRulesRef.createdAt)),
-    ]);
-    const pricingCategoryIds = Array.from(new Set(unitPrices.flatMap((row) => (row.pricingCategoryId ? [row.pricingCategoryId] : []))));
-    const [tiers, departureOverrides, pricingCategories] = await Promise.all([
-        unitPrices.length > 0
-            ? db
-                .select({
-                id: optionUnitTiersRef.id,
-                optionUnitPriceRuleId: optionUnitTiersRef.optionUnitPriceRuleId,
-                minQuantity: optionUnitTiersRef.minQuantity,
-                maxQuantity: optionUnitTiersRef.maxQuantity,
-                sellAmountCents: optionUnitTiersRef.sellAmountCents,
-                sortOrder: optionUnitTiersRef.sortOrder,
-            })
-                .from(optionUnitTiersRef)
-                .where(and(inArray(optionUnitTiersRef.optionUnitPriceRuleId, unitPrices.map((row) => row.id)), eq(optionUnitTiersRef.active, true)))
-                .orderBy(asc(optionUnitTiersRef.sortOrder), asc(optionUnitTiersRef.minQuantity))
-            : Promise.resolve([]),
-        input.departureId
-            ? db
-                .select({
-                optionUnitId: departurePriceOverridesRef.optionUnitId,
-                sellAmountCents: departurePriceOverridesRef.sellAmountCents,
-            })
-                .from(departurePriceOverridesRef)
-                .where(and(eq(departurePriceOverridesRef.departureId, input.departureId), eq(departurePriceOverridesRef.priceCatalogId, catalog.id), eq(departurePriceOverridesRef.active, true)))
-            : Promise.resolve([]),
-        pricingCategoryIds.length > 0
-            ? db
-                .select({
-                id: pricingCategoriesRef.id,
-                name: pricingCategoriesRef.name,
-                code: pricingCategoriesRef.code,
-                categoryType: pricingCategoriesRef.categoryType,
-                minAge: pricingCategoriesRef.minAge,
-                maxAge: pricingCategoriesRef.maxAge,
-                metadata: pricingCategoriesRef.metadata,
-                sortOrder: pricingCategoriesRef.sortOrder,
-            })
-                .from(pricingCategoriesRef)
-                .where(and(inArray(pricingCategoriesRef.id, pricingCategoryIds), eq(pricingCategoriesRef.active, true)))
-                .orderBy(asc(pricingCategoriesRef.sortOrder), asc(pricingCategoriesRef.name))
-            : Promise.resolve([]),
-    ]);
-    const tiersByUnitPriceId = new Map();
-    for (const tier of tiers) {
-        const existing = tiersByUnitPriceId.get(tier.optionUnitPriceRuleId) ?? [];
-        existing.push(tier);
-        tiersByUnitPriceId.set(tier.optionUnitPriceRuleId, existing);
-    }
-    const departureOverrideByUnitId = new Map(departureOverrides.map((row) => [row.optionUnitId, row]));
-    return {
-        catalog: catalog,
-        options: options,
-        rules: rules,
-        pricingCategories: pricingCategories,
-        unitPrices: unitPrices.map((row) => {
-            const override = departureOverrideByUnitId.get(row.unitId);
-            return {
-                ...row,
-                sellAmountCents: override?.sellAmountCents ?? row.sellAmountCents,
-                tiers: override ? [] : (tiersByUnitPriceId.get(row.id) ?? []),
-            };
-        }),
-    };
-}
-async function buildSessionSnapshot(db, bookingId) {
-    const [booking, participants, items, allocations, itemParticipantLinks, state] = await Promise.all([
-        bookingsService.getBookingById(db, bookingId),
-        db
-            .select()
-            .from(bookingTravelers)
-            .where(eq(bookingTravelers.bookingId, bookingId))
-            .orderBy(asc(bookingTravelers.createdAt)),
-        db
-            .select()
-            .from(bookingItems)
-            .where(eq(bookingItems.bookingId, bookingId))
-            .orderBy(asc(bookingItems.createdAt)),
-        db
-            .select()
-            .from(bookingAllocations)
-            .where(eq(bookingAllocations.bookingId, bookingId))
-            .orderBy(asc(bookingAllocations.createdAt)),
-        db
-            .select({
-            id: bookingItemTravelers.id,
-            bookingItemId: bookingItemTravelers.bookingItemId,
-            travelerId: bookingItemTravelers.travelerId,
-            role: bookingItemTravelers.role,
-            isPrimary: bookingItemTravelers.isPrimary,
-        })
-            .from(bookingItemTravelers)
-            .innerJoin(bookingItems, eq(bookingItems.id, bookingItemTravelers.bookingItemId))
-            .where(eq(bookingItems.bookingId, bookingId))
-            .orderBy(asc(bookingItemTravelers.createdAt)),
-        getWizardSessionState(db, bookingId),
-    ]);
-    if (!booking) {
-        return null;
-    }
-    const itemLinksByItemId = new Map();
-    for (const link of itemParticipantLinks) {
-        const existing = itemLinksByItemId.get(link.bookingItemId) ?? [];
-        existing.push({
-            id: link.id,
-            travelerId: link.travelerId,
-            role: link.role,
-            isPrimary: link.isPrimary,
-        });
-        itemLinksByItemId.set(link.bookingItemId, existing);
-    }
-    const hasTraveler = countTravelerParticipants(participants) > 0;
-    const hasTravelers = participants.length > 0;
-    const hasPrimaryTraveler = participants.some((participant) => participant.isPrimary);
-    const hasItems = items.length > 0;
-    const hasAllocations = allocations.length > 0;
-    return {
-        sessionId: booking.id,
-        bookingNumber: booking.bookingNumber,
-        status: booking.status,
-        externalBookingRef: booking.externalBookingRef ?? null,
-        communicationLanguage: booking.communicationLanguage ?? null,
-        sellCurrency: booking.sellCurrency,
-        sellAmountCents: booking.sellAmountCents ?? null,
-        startDate: normalizeDate(booking.startDate),
-        endDate: normalizeDate(booking.endDate),
-        pax: booking.pax ?? null,
-        holdExpiresAt: normalizeDateTime(booking.holdExpiresAt),
-        confirmedAt: normalizeDateTime(booking.confirmedAt),
-        expiredAt: normalizeDateTime(booking.expiredAt),
-        cancelledAt: normalizeDateTime(booking.cancelledAt),
-        completedAt: normalizeDateTime(booking.completedAt),
-        travelers: participants.map((participant) => ({
-            id: participant.id,
-            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,
-            specialRequests: participant.specialRequests ?? null,
-            isPrimary: participant.isPrimary,
-            notes: participant.notes ?? null,
-        })),
-        items: items.map((item) => ({
-            id: item.id,
-            title: item.title,
-            description: item.description ?? null,
-            itemType: item.itemType,
-            status: item.status,
-            serviceDate: normalizeDate(item.serviceDate),
-            startsAt: normalizeDateTime(item.startsAt),
-            endsAt: normalizeDateTime(item.endsAt),
-            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.optionUnitId ?? null,
-            pricingCategoryId: item.pricingCategoryId ?? null,
-            travelerLinks: itemLinksByItemId.get(item.id) ?? [],
-        })),
-        allocations: allocations.map((allocation) => ({
-            id: allocation.id,
-            bookingItemId: allocation.bookingItemId ?? null,
-            productId: allocation.productId ?? null,
-            optionId: allocation.optionId ?? null,
-            optionUnitId: allocation.optionUnitId ?? null,
-            pricingCategoryId: allocation.pricingCategoryId ?? null,
-            availabilitySlotId: allocation.availabilitySlotId ?? null,
-            quantity: allocation.quantity,
-            allocationType: allocation.allocationType,
-            status: allocation.status,
-            holdExpiresAt: normalizeDateTime(allocation.holdExpiresAt),
-            confirmedAt: normalizeDateTime(allocation.confirmedAt),
-            releasedAt: normalizeDateTime(allocation.releasedAt),
-        })),
-        checklist: {
-            hasTravelers,
-            hasPrimaryTraveler,
-            hasItems,
-            hasAllocations,
-            readyForConfirmation: booking.status === "on_hold" &&
-                hasTravelers &&
-                hasTraveler &&
-                hasPrimaryTraveler &&
-                hasItems &&
-                hasAllocations,
-        },
-        state,
-    };
-}
-export const publicBookingsService = {
-    async createSession(db, input, userId, resolvers = {}) {
-        const travelers = input.travelers ?? [];
-        const travelerCount = countTravelerParticipants(travelers);
-        const bookingNumber = await generateBookingNumber(db);
-        const result = await bookingsService.reserveBooking(db, {
-            bookingNumber,
-            sourceType: "direct",
-            externalBookingRef: input.externalBookingRef ?? null,
-            communicationLanguage: input.communicationLanguage ?? null,
-            sellCurrency: input.sellCurrency,
-            baseCurrency: input.baseCurrency ?? null,
-            sellAmountCents: input.sellAmountCents ?? null,
-            baseSellAmountCents: input.baseSellAmountCents ?? null,
-            costAmountCents: input.costAmountCents ?? null,
-            baseCostAmountCents: input.baseCostAmountCents ?? null,
-            marginPercent: input.marginPercent ?? null,
-            startDate: input.startDate ?? null,
-            endDate: input.endDate ?? null,
-            pax: input.pax ?? (travelerCount > 0 ? travelerCount : null),
-            holdMinutes: input.holdMinutes,
-            holdExpiresAt: input.holdExpiresAt ?? null,
-            items: input.items.map((item) => ({
-                ...item,
-                sellCurrency: item.sellCurrency ?? input.sellCurrency,
-                costCurrency: item.costCurrency ?? null,
-                description: item.description ?? null,
-                notes: item.notes ?? null,
-                productId: item.productId ?? null,
-                optionId: item.optionId ?? null,
-                optionUnitId: item.optionUnitId ?? null,
-                pricingCategoryId: item.pricingCategoryId ?? null,
-                sourceSnapshotId: item.sourceSnapshotId ?? null,
-                sourceOfferId: null,
-                metadata: item.metadata ?? null,
-            })),
-            internalNotes: null,
-        }, userId);
-        if (!("booking" in result) || !result.booking) {
-            return result;
-        }
-        for (const participant of travelers) {
-            const personId = await safeResolveTravelerPerson(db, resolvers.resolveTravelerPerson, {
-                firstName: participant.firstName,
-                lastName: participant.lastName,
-                email: participant.email ?? null,
-                phone: participant.phone ?? null,
-                preferredLanguage: participant.preferredLanguage ?? null,
-            }, result.booking.id);
-            await bookingsService.createTravelerRecord(db, result.booking.id, {
-                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,
-                specialRequests: participant.specialRequests ?? null,
-                isPrimary: participant.isPrimary,
-                notes: participant.notes ?? null,
-                personId,
-            }, userId);
-        }
-        const session = await buildSessionSnapshot(db, result.booking.id);
-        return session ? { status: "ok", session } : { status: "not_found" };
-    },
-    getSessionById(db, bookingId) {
-        return buildSessionSnapshot(db, bookingId);
-    },
-    async getSessionState(db, bookingId) {
-        const booking = await bookingsService.getBookingById(db, bookingId);
-        if (!booking) {
-            return null;
-        }
-        return getWizardSessionState(db, bookingId);
-    },
-    async updateSessionState(db, bookingId, input, resolvers = {}, userId) {
-        const booking = await bookingsService.getBookingById(db, bookingId);
-        if (!booking) {
-            return { status: "not_found" };
-        }
-        const state = await upsertWizardSessionState(db, bookingId, input);
-        if (!state) {
-            return { status: "not_found" };
-        }
-        const bookingContact = extractBookingContactFromStatePayload(state.payload);
-        if (bookingContact) {
-            // Resolve a CRM person from the billing snapshot when a resolver
-            // is wired — issue #961 calls out that storefront bookings used
-            // to land with `person_id = NULL`, leaving every customer outside
-            // the CRM until each operator wired their own bridge.
-            const personId = booking.personId
-                ? booking.personId
-                : await safeResolveBillingPerson(db, resolvers.resolveBillingPerson, {
-                    firstName: bookingContact.contactFirstName,
-                    lastName: bookingContact.contactLastName,
-                    email: bookingContact.contactEmail,
-                    phone: bookingContact.contactPhone,
-                    preferredLanguage: null,
-                }, bookingId);
-            await bookingsService.updateBooking(db, bookingId, {
-                ...bookingContact,
-                ...(personId && booking.personId !== personId ? { personId } : {}),
-            });
-        }
-        await syncTravelerRowsFromStatePayload(db, bookingId, state.payload, resolvers, userId);
-        return { status: "ok", state };
-    },
-    async updateSession(db, bookingId, input, userId, resolvers = {}) {
-        const booking = await bookingsService.getBookingById(db, bookingId);
-        if (!booking) {
-            return { status: "not_found" };
-        }
-        if (input.externalBookingRef !== undefined ||
-            input.communicationLanguage !== undefined ||
-            input.pax !== undefined) {
-            await bookingsService.updateBooking(db, bookingId, {
-                externalBookingRef: input.externalBookingRef,
-                communicationLanguage: input.communicationLanguage,
-                pax: input.pax,
-            });
-        }
-        const travelers = input.travelers;
-        const removedTravelerIds = input.removedTravelerIds ?? [];
-        for (const travelerId of removedTravelerIds) {
-            const participant = await bookingsService.getTravelerRecordById(db, bookingId, travelerId);
-            if (participant) {
-                await bookingsService.deleteTravelerRecord(db, participant.id);
-            }
-        }
-        if (travelers) {
-            for (const participant of travelers) {
-                if (participant.id) {
-                    const existing = await bookingsService.getTravelerRecordById(db, bookingId, participant.id);
-                    if (!existing) {
-                        return { status: "participant_not_found" };
-                    }
-                    await bookingsService.updateTravelerRecord(db, participant.id, {
-                        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,
-                        specialRequests: participant.specialRequests ?? null,
-                        isPrimary: participant.isPrimary,
-                        notes: participant.notes ?? null,
-                    });
-                    continue;
-                }
-                const personId = await safeResolveTravelerPerson(db, resolvers.resolveTravelerPerson, {
-                    firstName: participant.firstName,
-                    lastName: participant.lastName,
-                    email: participant.email ?? null,
-                    phone: participant.phone ?? null,
-                    preferredLanguage: participant.preferredLanguage ?? null,
-                }, bookingId);
-                await bookingsService.createTravelerRecord(db, bookingId, {
-                    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,
-                    specialRequests: participant.specialRequests ?? null,
-                    isPrimary: participant.isPrimary,
-                    notes: participant.notes ?? null,
-                    personId,
-                }, userId);
-            }
-        }
-        if (input.holdMinutes !== undefined || input.holdExpiresAt !== undefined) {
-            const holdResult = await bookingsService.extendBookingHold(db, bookingId, {
-                holdMinutes: input.holdMinutes,
-                holdExpiresAt: input.holdExpiresAt,
-            }, userId);
-            if (holdResult.status !== "ok") {
-                return holdResult;
-            }
-        }
-        if (input.pax === undefined && (travelers || removedTravelerIds.length > 0)) {
-            const participants = await db
-                .select({ participantType: bookingTravelers.participantType })
-                .from(bookingTravelers)
-                .where(eq(bookingTravelers.bookingId, bookingId));
-            const travelerCount = countTravelerParticipants(participants);
-            await bookingsService.updateBooking(db, bookingId, {
-                pax: travelerCount > 0 ? travelerCount : null,
-            });
-        }
-        const session = await buildSessionSnapshot(db, bookingId);
-        return session ? { status: "ok", session } : { status: "not_found" };
-    },
-    async repriceSession(db, bookingId, input) {
-        const [booking, items] = await Promise.all([
-            bookingsService.getBookingById(db, bookingId),
-            db
-                .select()
-                .from(bookingItems)
-                .where(eq(bookingItems.bookingId, bookingId))
-                .orderBy(asc(bookingItems.createdAt)),
-        ]);
-        if (!booking) {
-            return { status: "not_found" };
-        }
-        const selectedItemIds = input.selections.map((selection) => selection.itemId);
-        const itemById = new Map(items.map((item) => [item.id, item]));
-        for (const selection of input.selections) {
-            if (!itemById.has(selection.itemId)) {
-                return { status: "invalid_selection" };
-            }
-        }
-        const requestedUnitIds = Array.from(new Set(input.selections
-            .map((selection) => selection.optionUnitId)
-            .filter((value) => Boolean(value))));
-        const requestedUnits = requestedUnitIds.length > 0
-            ? await db.select().from(optionUnitsRef).where(inArray(optionUnitsRef.id, requestedUnitIds))
-            : [];
-        const requestedUnitById = new Map(requestedUnits.map((unit) => [unit.id, unit]));
-        const pricingWarnings = [];
-        const pricedItems = [];
-        let resolvedCatalogId = input.catalogId ?? null;
-        let resolvedCurrency = booking.sellCurrency;
-        for (const selection of input.selections) {
-            const item = itemById.get(selection.itemId);
-            if (!item?.productId) {
-                return { status: "invalid_selection" };
-            }
-            const optionId = selection.optionId === undefined
-                ? (item.optionId ?? undefined)
-                : (selection.optionId ?? undefined);
-            const quantity = selection.quantity ?? item.quantity;
-            const pricingCategoryId = selection.pricingCategoryId === undefined
-                ? (item.pricingCategoryId ?? null)
-                : (selection.pricingCategoryId ?? null);
-            const selectedUnitId = selection.optionUnitId === undefined
-                ? (item.optionUnitId ?? null)
-                : (selection.optionUnitId ?? null);
-            const snapshot = await resolveSessionPricingSnapshot(db, item.productId, {
-                catalogId: input.catalogId,
-                departureId: item.availabilitySlotId ?? undefined,
-                optionId,
-            });
-            if (!snapshot) {
-                return { status: "pricing_unavailable" };
-            }
-            resolvedCatalogId = snapshot.catalog.id;
-            resolvedCurrency = snapshot.catalog.currencyCode ?? booking.sellCurrency;
-            const option = snapshot.options.find((candidate) => candidate.id === optionId) ??
-                snapshot.options[0] ??
-                null;
-            if (!option) {
-                return { status: "pricing_unavailable" };
-            }
-            const rule = snapshot.rules.find((candidate) => candidate.optionId === option.id && candidate.isDefault) ??
-                snapshot.rules.find((candidate) => candidate.optionId === option.id) ??
-                null;
-            if (!rule) {
-                return { status: "pricing_unavailable" };
-            }
-            const ruleUnitPrices = snapshot.unitPrices.filter((candidate) => candidate.optionPriceRuleId === rule.id);
-            const unitPriceCandidates = ruleUnitPrices.filter((candidate) => {
-                if (selectedUnitId && candidate.unitId !== selectedUnitId) {
-                    return false;
-                }
-                if (pricingCategoryId && candidate.pricingCategoryId !== pricingCategoryId) {
-                    return false;
-                }
-                if (candidate.minQuantity !== null && quantity < candidate.minQuantity) {
-                    return false;
-                }
-                if (candidate.maxQuantity !== null && quantity > candidate.maxQuantity) {
-                    return false;
-                }
-                return true;
-            });
-            const fallbackUnitPrice = !pricingCategoryId && !selectedUnitId
-                ? (ruleUnitPrices.find((candidate) => candidate.pricingCategoryId === null &&
-                    (candidate.minQuantity === null || quantity >= candidate.minQuantity) &&
-                    (candidate.maxQuantity === null || quantity <= candidate.maxQuantity)) ?? null)
-                : null;
-            const unitPrice = unitPriceCandidates[0] ?? fallbackUnitPrice;
-            if ((selectedUnitId || ruleUnitPrices.length > 0) &&
-                !unitPrice &&
-                rule.pricingMode !== "per_booking") {
-                return { status: "pricing_unavailable" };
-            }
-            const unit = selectedUnitId ? (requestedUnitById.get(selectedUnitId) ?? null) : null;
-            const unitSellAmountCents = unitPrice
-                ? resolveTierAmount(unitPrice.tiers, quantity, unitPrice.sellAmountCents)
-                : rule.baseSellAmountCents;
-            const pricingMode = unitPrice?.pricingMode ?? rule.pricingMode;
-            const totalSellAmountCents = computeLineTotal(pricingMode, unitSellAmountCents, quantity, rule.baseSellAmountCents);
-            const warnings = buildUnitWarnings(unit, quantity, booking.pax ?? null);
-            if (selectedUnitId && !unit) {
-                warnings.push("Selected room/unit metadata is not available in the current catalog.");
-            }
-            if (pricingMode === "on_request") {
-                warnings.push("Selected option requires manual pricing confirmation.");
-            }
-            pricingWarnings.push(...warnings);
-            pricedItems.push({
-                itemId: item.id,
-                title: item.title,
-                productId: item.productId ?? null,
-                optionId: option.id,
-                optionUnitId: selectedUnitId,
-                optionUnitName: unit?.name ?? unitPrice?.unitName ?? null,
-                optionUnitType: unit?.unitType ?? unitPrice?.unitType ?? null,
-                pricingCategoryId,
-                quantity,
-                pricingMode,
-                unitSellAmountCents,
-                totalSellAmountCents,
-                warnings,
-            });
-        }
-        const totalSellAmountCents = items.reduce((total, item) => {
-            const repriced = pricedItems.find((candidate) => candidate.itemId === item.id);
-            return total + (repriced?.totalSellAmountCents ?? item.totalSellAmountCents ?? 0);
-        }, 0);
-        let session = null;
-        if (input.applyToSession) {
-            const activeAllocations = selectedItemIds.length > 0
-                ? await db
-                    .select()
-                    .from(bookingAllocations)
-                    .where(and(eq(bookingAllocations.bookingId, bookingId), inArray(bookingAllocations.bookingItemId, selectedItemIds), or(eq(bookingAllocations.status, "held"), eq(bookingAllocations.status, "confirmed"))))
-                : [];
-            const activeAllocationsByItemId = new Map();
-            for (const allocation of activeAllocations) {
-                const existing = activeAllocationsByItemId.get(allocation.bookingItemId) ?? [];
-                existing.push(allocation);
-                activeAllocationsByItemId.set(allocation.bookingItemId, existing);
-            }
-            const quantityChangedWithActiveAllocation = pricedItems.some((pricedItem) => {
-                const item = itemById.get(pricedItem.itemId);
-                return Boolean(item &&
-                    item.quantity !== pricedItem.quantity &&
-                    (activeAllocationsByItemId.get(pricedItem.itemId)?.length ?? 0) > 0);
-            });
-            if (quantityChangedWithActiveAllocation) {
-                return { status: "quantity_change_requires_reallocation" };
-            }
-            await db.transaction(async (tx) => {
-                for (const pricedItem of pricedItems) {
-                    await tx
-                        .update(bookingItems)
-                        .set({
-                        optionId: pricedItem.optionId,
-                        optionUnitId: pricedItem.optionUnitId,
-                        pricingCategoryId: pricedItem.pricingCategoryId,
-                        quantity: pricedItem.quantity,
-                        sellCurrency: resolvedCurrency,
-                        unitSellAmountCents: pricedItem.unitSellAmountCents,
-                        totalSellAmountCents: pricedItem.totalSellAmountCents,
-                        updatedAt: new Date(),
-                    })
-                        .where(eq(bookingItems.id, pricedItem.itemId));
-                    await tx
-                        .update(bookingAllocations)
-                        .set({
-                        optionId: pricedItem.optionId,
-                        optionUnitId: pricedItem.optionUnitId,
-                        pricingCategoryId: pricedItem.pricingCategoryId,
-                        updatedAt: new Date(),
-                    })
-                        .where(and(eq(bookingAllocations.bookingId, bookingId), eq(bookingAllocations.bookingItemId, pricedItem.itemId), or(eq(bookingAllocations.status, "held"), eq(bookingAllocations.status, "confirmed"))));
-                }
-                await tx
-                    .update(bookings)
-                    .set({
-                    sellCurrency: resolvedCurrency,
-                    sellAmountCents: totalSellAmountCents,
-                    updatedAt: new Date(),
-                })
-                    .where(eq(bookings.id, bookingId));
-            });
-            session = await buildSessionSnapshot(db, bookingId);
-        }
-        return {
-            status: "ok",
-            pricing: {
-                sessionId: bookingId,
-                catalogId: resolvedCatalogId,
-                currencyCode: resolvedCurrency,
-                totalSellAmountCents,
-                items: pricedItems,
-                warnings: Array.from(new Set(pricingWarnings)),
-                appliedToSession: input.applyToSession,
-            },
-            session,
-        };
-    },
-    async confirmSession(db, bookingId, input, userId) {
-        const result = await bookingsService.confirmBooking(db, bookingId, input, userId);
-        if (result.status !== "ok") {
-            return result;
-        }
-        const session = await buildSessionSnapshot(db, bookingId);
-        return session ? { status: "ok", session } : { status: "not_found" };
-    },
-    async expireSession(db, bookingId, input, userId, runtime = {}) {
-        const result = await bookingsService.expireBooking(db, bookingId, input, userId, runtime);
-        if (result.status !== "ok") {
-            return result;
-        }
-        const session = await buildSessionSnapshot(db, bookingId);
-        return session ? { status: "ok", session } : { status: "not_found" };
-    },
-    async getOverview(db, query) {
-        return buildOverviewSnapshot(db, query);
-    },
-    async getOverviewByGuestAccess(db, query) {
-        return buildOverviewSnapshot(db, query);
-    },
-    async getOverviewByLookup(db, query) {
-        return buildOverviewSnapshot(db, query);
-    },
-};
+export * from "./service-public-core.js";