@voyant-travel/finance 0.119.5

package/dist/service-profitability.js

@@ -0,0 +1,794 @@
+// agent-quality: file-size exception -- owner: finance; existing service module stays co-located until a dedicated split preserves behavior and tests.
+import { bookingItems, bookingTravelers } from "@voyant-travel/bookings/schema";
+import { and, eq, inArray, isNotNull, isNull, ne, sql } from "drizzle-orm";
+import { resolveFxMoneyBaseAmount } from "./fx-money.js";
+import { resolveInvoiceFxSettingsOrDefault } from "./invoice-fx.js";
+import { costCategories, invoices, supplierCostAllocations, supplierInvoiceLines, supplierInvoices, } from "./schema.js";
+import { executeBoundaryRows, normalizeDateOnly, sqlList } from "./service-boundary-sql.js";
+const num = (value) => Number(value ?? 0);
+function bucket(map, currency) {
+    let entry = map.get(currency);
+    if (!entry) {
+        entry = { revenue: 0, actual: 0, planned: 0 };
+        map.set(currency, entry);
+    }
+    return entry;
+}
+function newBaseSplit() {
+    return { snapshotBase: 0, residual: new Map() };
+}
+function addResidual(map, currency, amount) {
+    if (amount === 0)
+        return;
+    map.set(currency, (map.get(currency) ?? 0) + amount);
+}
+/** Resolve a base split to a single accounting-base figure via the rate map. */
+function resolveBaseSplit(split, rates, unconvertible) {
+    let total = split.snapshotBase;
+    for (const [currency, amount] of split.residual) {
+        const rate = rates.get(currency);
+        if (rate == null) {
+            if (amount !== 0)
+                unconvertible.add(currency);
+            continue;
+        }
+        total += amount * rate;
+    }
+    return total;
+}
+function margin(profitCents, revenueCents) {
+    if (revenueCents <= 0)
+        return null;
+    return Math.round((profitCents / revenueCents) * 1000) / 10;
+}
+/**
+ * Shared loader: runs the source queries once and assembles a per-departure
+ * accumulator plus the cost-breakdown aggregates that both reports surface.
+ *
+ * Each money source carries TWO base figures: the sum of recorded base snapshots
+ * (already in `baseCurrency`, summed verbatim) and the original-currency residual
+ * from rows lacking a snapshot (converted later via fallback rates). This keeps
+ * the rollup faithful to the rate that was in effect when each invoice was
+ * issued, instead of re-valuing everything at the latest rate.
+ */
+async function loadDepartureAccumulators(db, baseCurrency) {
+    const base = baseCurrency;
+    // Net sign for AR (credit notes subtract). Reused for total + base + residual.
+    // agent-quality: raw-sql reviewed -- owner: finance; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    const arSign = sql `case when ${invoices.invoiceType} = 'credit_note' then -1 else 1 end`;
+    // True when an invoice/allocation has a usable base snapshot in the accounting base.
+    // agent-quality: raw-sql reviewed -- owner: finance; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    const invSnapshotted = sql `${invoices.baseCurrency} = ${base} and ${invoices.baseTotalCents} is not null`;
+    // agent-quality: raw-sql reviewed -- owner: finance; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    const allocSnapshotted = sql `${supplierInvoices.baseCurrency} = ${base} and ${supplierCostAllocations.baseAmountCents} is not null`;
+    // agent-quality: raw-sql reviewed -- owner: finance; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    const lineSnapshotted = sql `${supplierInvoices.baseCurrency} = ${base} and ${supplierInvoices.baseTotalCents} is not null and ${supplierInvoices.totalCents} <> 0`;
+    const [itemRows, invoiceRows, departureCostRows, productCostRows, serviceTypeRows, unattributedRows,] = await Promise.all([
+        // Booked sell + planned cost per (departure, booking), with display snapshots.
+        db
+            .select({
+            departureId: bookingItems.availabilitySlotId,
+            bookingId: bookingItems.bookingId,
+            productId: sql `max(${bookingItems.productId})`,
+            productName: sql `max(${bookingItems.productNameSnapshot})`,
+            departureLabel: sql `max(${bookingItems.departureLabelSnapshot})`,
+            departureDate: sql `to_char(min(${bookingItems.startsAt}) at time zone 'UTC', 'YYYY-MM-DD')`,
+            sellCurrency: bookingItems.sellCurrency,
+            sellCents: sql `coalesce(sum(${bookingItems.totalSellAmountCents}), 0)::bigint`,
+            costCurrency: bookingItems.costCurrency,
+            plannedCostCents: sql `coalesce(sum(${bookingItems.totalCostAmountCents}), 0)::bigint`,
+        })
+            .from(bookingItems)
+            .where(isNotNull(bookingItems.availabilitySlotId))
+            .groupBy(bookingItems.availabilitySlotId, bookingItems.bookingId, bookingItems.sellCurrency, bookingItems.costCurrency),
+        // Invoiced AR per (booking, currency). Credit notes net down; proforma/draft/void excluded.
+        // `baseTotalCents` sums recorded base snapshots; `residualTotalCents` is the
+        // original-currency remainder from invoices without one.
+        db
+            .select({
+            bookingId: invoices.bookingId,
+            currency: invoices.currency,
+            totalCents: sql `coalesce(sum(${arSign} * ${invoices.totalCents}), 0)::bigint`,
+            baseTotalCents: sql `coalesce(sum(${arSign} * (case when ${invSnapshotted} then ${invoices.baseTotalCents} else 0 end)), 0)::bigint`,
+            residualTotalCents: sql `coalesce(sum(${arSign} * (case when ${invSnapshotted} then 0 else ${invoices.totalCents} end)), 0)::bigint`,
+        })
+            .from(invoices)
+            .where(and(ne(invoices.status, "void"), ne(invoices.status, "draft"), ne(invoices.invoiceType, "proforma")))
+            .groupBy(invoices.bookingId, invoices.currency),
+        // Actual cost: departure-targeted allocations per (departure, currency).
+        db
+            .select({
+            departureId: supplierCostAllocations.departureId,
+            currency: supplierInvoices.currency,
+            amountCents: sql `coalesce(sum(${supplierCostAllocations.amountCents}), 0)::bigint`,
+            baseAmountCents: sql `coalesce(sum(case when ${allocSnapshotted} then ${supplierCostAllocations.baseAmountCents} else 0 end), 0)::bigint`,
+            residualAmountCents: sql `coalesce(sum(case when ${allocSnapshotted} then 0 else ${supplierCostAllocations.amountCents} end), 0)::bigint`,
+        })
+            .from(supplierCostAllocations)
+            .innerJoin(supplierInvoices, eq(supplierCostAllocations.supplierInvoiceId, supplierInvoices.id))
+            .where(and(eq(supplierCostAllocations.targetType, "departure"), isNotNull(supplierCostAllocations.departureId), ne(supplierInvoices.status, "void"), isNull(supplierInvoices.deletedAt)))
+            .groupBy(supplierCostAllocations.departureId, supplierInvoices.currency),
+        // Actual cost: product-targeted allocations per (product, currency) — not tied to a departure.
+        db
+            .select({
+            productId: supplierCostAllocations.productId,
+            currency: supplierInvoices.currency,
+            amountCents: sql `coalesce(sum(${supplierCostAllocations.amountCents}), 0)::bigint`,
+            baseAmountCents: sql `coalesce(sum(case when ${allocSnapshotted} then ${supplierCostAllocations.baseAmountCents} else 0 end), 0)::bigint`,
+            residualAmountCents: sql `coalesce(sum(case when ${allocSnapshotted} then 0 else ${supplierCostAllocations.amountCents} end), 0)::bigint`,
+        })
+            .from(supplierCostAllocations)
+            .innerJoin(supplierInvoices, eq(supplierCostAllocations.supplierInvoiceId, supplierInvoices.id))
+            .where(and(eq(supplierCostAllocations.targetType, "product"), isNotNull(supplierCostAllocations.productId), ne(supplierInvoices.status, "void"), isNull(supplierInvoices.deletedAt)))
+            .groupBy(supplierCostAllocations.productId, supplierInvoices.currency),
+        // Cost breakdown by configurable cost category. Summed from supplier-invoice
+        // LINE totals (not allocations) so categorizing a line shows up immediately,
+        // even before the cost is allocated to a departure. Lines without a category
+        // fall to "Uncategorized". Base = line total pro-rated by the invoice's
+        // snapshotted base/total ratio.
+        db
+            .select({
+            serviceType: sql `coalesce(${costCategories.name}, 'Uncategorized')`,
+            currency: supplierInvoices.currency,
+            amountCents: sql `coalesce(sum(${supplierInvoiceLines.totalAmountCents}), 0)::bigint`,
+            baseAmountCents: sql `coalesce(sum(case when ${lineSnapshotted} then round(${supplierInvoiceLines.totalAmountCents}::numeric * ${supplierInvoices.baseTotalCents} / ${supplierInvoices.totalCents}) else 0 end), 0)::bigint`,
+            residualAmountCents: sql `coalesce(sum(case when ${lineSnapshotted} then 0 else ${supplierInvoiceLines.totalAmountCents} end), 0)::bigint`,
+        })
+            .from(supplierInvoiceLines)
+            .innerJoin(supplierInvoices, eq(supplierInvoiceLines.supplierInvoiceId, supplierInvoices.id))
+            .leftJoin(costCategories, eq(supplierInvoiceLines.costCategoryId, costCategories.id))
+            .where(and(ne(supplierInvoices.status, "void"), isNull(supplierInvoices.deletedAt)))
+            // agent-quality: raw-sql reviewed -- owner: finance; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            .groupBy(sql `coalesce(${costCategories.name}, 'Uncategorized')`, supplierInvoices.currency),
+        // Recorded-but-unattributed cost — appears in AP totals, excluded from P&L.
+        db
+            .select({
+            currency: supplierInvoices.currency,
+            amountCents: sql `coalesce(sum(${supplierCostAllocations.amountCents}), 0)::bigint`,
+            baseAmountCents: sql `coalesce(sum(case when ${allocSnapshotted} then ${supplierCostAllocations.baseAmountCents} else 0 end), 0)::bigint`,
+            residualAmountCents: sql `coalesce(sum(case when ${allocSnapshotted} then 0 else ${supplierCostAllocations.amountCents} end), 0)::bigint`,
+        })
+            .from(supplierCostAllocations)
+            .innerJoin(supplierInvoices, eq(supplierCostAllocations.supplierInvoiceId, supplierInvoices.id))
+            .where(and(eq(supplierCostAllocations.targetType, "unattributed"), ne(supplierInvoices.status, "void"), isNull(supplierInvoices.deletedAt)))
+            .groupBy(supplierInvoices.currency),
+    ]);
+    const departures = new Map();
+    const ensure = (departureId) => {
+        let acc = departures.get(departureId);
+        if (!acc) {
+            acc = {
+                departureId,
+                productId: null,
+                productName: null,
+                departureLabel: null,
+                departureDate: null,
+                byCurrency: new Map(),
+                base: { revenue: 0, actual: 0, planned: 0 },
+                residual: new Map(),
+            };
+            departures.set(departureId, acc);
+        }
+        return acc;
+    };
+    const ensureResidual = (acc, currency) => {
+        let entry = acc.residual.get(currency);
+        if (!entry) {
+            entry = { revenue: 0, actual: 0, planned: 0 };
+            acc.residual.set(currency, entry);
+        }
+        return entry;
+    };
+    // Booking totals + per-departure sell, for proportional revenue attribution.
+    const bookingTotalSell = new Map();
+    const bookingSlotSell = new Map();
+    for (const row of itemRows) {
+        const departureId = row.departureId;
+        if (!departureId)
+            continue;
+        const acc = ensure(departureId);
+        acc.productId ??= row.productId;
+        acc.productName ??= row.productName;
+        acc.departureLabel ??= row.departureLabel;
+        acc.departureDate ??= row.departureDate;
+        const sellCents = num(row.sellCents);
+        const plannedCost = num(row.plannedCostCents);
+        if (row.costCurrency && plannedCost !== 0) {
+            bucket(acc.byCurrency, row.costCurrency).planned += plannedCost;
+            // Planned cost is a budget snapshot with no recorded FX, so it always
+            // routes through the fallback conversion (latest rate for that currency).
+            ensureResidual(acc, row.costCurrency).planned += plannedCost;
+        }
+        bookingTotalSell.set(row.bookingId, (bookingTotalSell.get(row.bookingId) ?? 0) + sellCents);
+        const slots = bookingSlotSell.get(row.bookingId) ?? [];
+        slots.push({ departureId, sellCents });
+        bookingSlotSell.set(row.bookingId, slots);
+    }
+    const invoicesByBooking = new Map();
+    for (const row of invoiceRows) {
+        const list = invoicesByBooking.get(row.bookingId) ?? [];
+        list.push({
+            currency: row.currency,
+            totalCents: num(row.totalCents),
+            baseTotalCents: num(row.baseTotalCents),
+            residualTotalCents: num(row.residualTotalCents),
+        });
+        invoicesByBooking.set(row.bookingId, list);
+    }
+    for (const [bookingId, invoiceList] of invoicesByBooking) {
+        const slots = bookingSlotSell.get(bookingId);
+        if (!slots || slots.length === 0)
+            continue; // invoice for a booking with no slotted items → not departure-attributable
+        const totalSell = bookingTotalSell.get(bookingId) ?? 0;
+        for (const slot of slots) {
+            const ratio = totalSell > 0 ? slot.sellCents / totalSell : 1 / slots.length;
+            const acc = ensure(slot.departureId);
+            for (const inv of invoiceList) {
+                bucket(acc.byCurrency, inv.currency).revenue += inv.totalCents * ratio;
+                acc.base.revenue += inv.baseTotalCents * ratio;
+                if (inv.residualTotalCents !== 0) {
+                    ensureResidual(acc, inv.currency).revenue += inv.residualTotalCents * ratio;
+                }
+            }
+        }
+    }
+    for (const row of departureCostRows) {
+        if (!row.departureId)
+            continue;
+        const acc = ensure(row.departureId);
+        bucket(acc.byCurrency, row.currency).actual += num(row.amountCents);
+        acc.base.actual += num(row.baseAmountCents);
+        ensureResidual(acc, row.currency).actual += num(row.residualAmountCents);
+    }
+    // Resolve friendly labels from availability_slots (+ product name) for every
+    // departure — fills cost-only departures that have no booking-item snapshot.
+    const departureIds = [...departures.keys()];
+    if (departureIds.length > 0) {
+        const slotRows = await executeBoundaryRows(db, 
+        // agent-quality: raw-sql reviewed -- owner: finance; Availability/Product are read-only profitability label sources and ids are parameter-bound.
+        sql `
+        SELECT avs.id, avs.date_local, avs.product_id, p.name AS product_name
+        FROM availability_slots avs
+        LEFT JOIN products p ON avs.product_id = p.id
+        WHERE avs.id IN (${sqlList(departureIds)})
+      `);
+        for (const slot of slotRows) {
+            const acc = departures.get(slot.id);
+            if (!acc)
+                continue;
+            const dateLocal = normalizeDateOnly(slot.date_local);
+            acc.departureLabel ??= dateLocal;
+            acc.departureDate ??= dateLocal;
+            acc.productId ??= slot.product_id;
+            acc.productName ??= slot.product_name;
+        }
+    }
+    const productActualCost = [];
+    const productActualCostBase = new Map();
+    for (const row of productCostRows) {
+        if (!row.productId)
+            continue;
+        productActualCost.push({
+            productId: row.productId,
+            currency: row.currency,
+            amountCents: num(row.amountCents),
+        });
+        let split = productActualCostBase.get(row.productId);
+        if (!split) {
+            split = newBaseSplit();
+            productActualCostBase.set(row.productId, split);
+        }
+        split.snapshotBase += num(row.baseAmountCents);
+        addResidual(split.residual, row.currency, num(row.residualAmountCents));
+    }
+    const costByServiceType = [];
+    const costByServiceTypeBase = new Map();
+    for (const row of serviceTypeRows) {
+        const amountCents = num(row.amountCents);
+        if (amountCents !== 0) {
+            costByServiceType.push({ serviceType: row.serviceType, currency: row.currency, amountCents });
+        }
+        let split = costByServiceTypeBase.get(row.serviceType);
+        if (!split) {
+            split = newBaseSplit();
+            costByServiceTypeBase.set(row.serviceType, split);
+        }
+        split.snapshotBase += num(row.baseAmountCents);
+        addResidual(split.residual, row.currency, num(row.residualAmountCents));
+    }
+    const unattributed = [];
+    const unattributedBase = newBaseSplit();
+    for (const row of unattributedRows) {
+        const amountCents = num(row.amountCents);
+        if (amountCents !== 0)
+            unattributed.push({ currency: row.currency, amountCents });
+        unattributedBase.snapshotBase += num(row.baseAmountCents);
+        addResidual(unattributedBase.residual, row.currency, num(row.residualAmountCents));
+    }
+    return {
+        baseCurrency: base,
+        departures,
+        productActualCost,
+        productActualCostBase,
+        costByServiceType,
+        costByServiceTypeBase,
+        unattributed,
+        unattributedBase,
+    };
+}
+function withinDateRange(date, from, to) {
+    if (!from && !to)
+        return true;
+    if (!date)
+        return false;
+    if (from && date < from)
+        return false;
+    if (to && date > to)
+        return false;
+    return true;
+}
+export async function getDepartureProfitability(db, query, options = {}) {
+    const baseCurrency = (await resolveInvoiceFxSettingsOrDefault(db, options)).baseCurrency;
+    const loaded = await loadDepartureAccumulators(db, baseCurrency);
+    const { departures, costByServiceType, costByServiceTypeBase, unattributed, unattributedBase } = loaded;
+    const rows = [];
+    const filtered = [];
+    for (const acc of departures.values()) {
+        if (query.departureId && acc.departureId !== query.departureId)
+            continue;
+        if (query.productId && acc.productId !== query.productId)
+            continue;
+        if (!withinDateRange(acc.departureDate, query.from, query.to))
+            continue;
+        filtered.push(acc);
+        for (const [currency, totals] of acc.byCurrency) {
+            if (query.currency && currency !== query.currency)
+                continue;
+            const revenueCents = Math.round(totals.revenue);
+            const actualCostCents = Math.round(totals.actual);
+            const plannedCostCents = Math.round(totals.planned);
+            const profitCents = revenueCents - actualCostCents;
+            rows.push({
+                departureId: acc.departureId,
+                departureLabel: acc.departureLabel,
+                productId: acc.productId,
+                productName: acc.productName,
+                departureDate: acc.departureDate,
+                currency,
+                revenueCents,
+                actualCostCents,
+                plannedCostCents,
+                profitCents,
+                marginPercent: margin(profitCents, revenueCents),
+                varianceCents: plannedCostCents - actualCostCents,
+            });
+        }
+    }
+    rows.sort((a, b) => (a.departureDate ?? "").localeCompare(b.departureDate ?? "") ||
+        a.departureId.localeCompare(b.departureId) ||
+        a.currency.localeCompare(b.currency));
+    // Accounting-base rollup. Always present and computed in the operator base
+    // currency: snapshots are summed verbatim, only legacy residuals are converted.
+    const residualCurrencies = collectResidualCurrencies(filtered.flatMap((acc) => [...acc.residual.keys()]), costByServiceTypeBase, unattributedBase);
+    const { rates, unconvertible } = await buildBaseRates(db, residualCurrencies, baseCurrency, options);
+    const baseRows = filtered
+        .map((acc) => {
+        const totals = baseFromAcc(acc.base, acc.residual, rates);
+        const revenueCents = Math.round(totals.revenue);
+        const actualCostCents = Math.round(totals.actual);
+        const plannedCostCents = Math.round(totals.planned);
+        const profitCents = revenueCents - actualCostCents;
+        return {
+            departureId: acc.departureId,
+            departureLabel: acc.departureLabel,
+            productId: acc.productId,
+            productName: acc.productName,
+            departureDate: acc.departureDate,
+            currency: baseCurrency,
+            revenueCents,
+            actualCostCents,
+            plannedCostCents,
+            profitCents,
+            marginPercent: margin(profitCents, revenueCents),
+            varianceCents: plannedCostCents - actualCostCents,
+        };
+    })
+        .sort((a, b) => (a.departureDate ?? "").localeCompare(b.departureDate ?? "") ||
+        a.departureId.localeCompare(b.departureId));
+    return {
+        rows,
+        costByServiceType: filterCostByCurrency(costByServiceType, query.currency),
+        unattributed: filterCostByCurrency(unattributed, query.currency),
+        base: {
+            currency: baseCurrency,
+            rows: baseRows,
+            costByServiceType: baseCostByServiceType(costByServiceTypeBase, rates, baseCurrency),
+            unattributedCents: Math.round(resolveBaseSplit(unattributedBase, rates, new Set())),
+            unconvertibleCurrencies: unconvertible,
+        },
+    };
+}
+export async function getProductProfitability(db, query, options = {}) {
+    const baseCurrency = (await resolveInvoiceFxSettingsOrDefault(db, options)).baseCurrency;
+    const loaded = await loadDepartureAccumulators(db, baseCurrency);
+    const { departures, productActualCost, productActualCostBase, costByServiceType, costByServiceTypeBase, unattributed, unattributedBase, } = loaded;
+    const products = new Map();
+    const ensureProduct = (productId) => {
+        let acc = products.get(productId);
+        if (!acc) {
+            acc = {
+                productId,
+                productName: null,
+                byCurrency: new Map(),
+                base: { revenue: 0, actual: 0, planned: 0 },
+                residual: new Map(),
+                baseDepartures: new Set(),
+            };
+            products.set(productId, acc);
+        }
+        return acc;
+    };
+    const productBucket = (acc, currency) => {
+        let entry = acc.byCurrency.get(currency);
+        if (!entry) {
+            entry = { revenue: 0, actual: 0, planned: 0, departures: new Set() };
+            acc.byCurrency.set(currency, entry);
+        }
+        return entry;
+    };
+    const productResidual = (acc, currency) => {
+        let entry = acc.residual.get(currency);
+        if (!entry) {
+            entry = { revenue: 0, actual: 0, planned: 0 };
+            acc.residual.set(currency, entry);
+        }
+        return entry;
+    };
+    for (const dep of departures.values()) {
+        if (!dep.productId)
+            continue;
+        if (!withinDateRange(dep.departureDate, query.from, query.to))
+            continue;
+        const acc = ensureProduct(dep.productId);
+        acc.productName ??= dep.productName;
+        for (const [currency, totals] of dep.byCurrency) {
+            if (query.currency && currency !== query.currency)
+                continue;
+            const entry = productBucket(acc, currency);
+            entry.revenue += totals.revenue;
+            entry.actual += totals.actual;
+            entry.planned += totals.planned;
+            entry.departures.add(dep.departureId);
+        }
+        // Base rollup aggregates across currencies (no currency filter).
+        acc.base.revenue += dep.base.revenue;
+        acc.base.actual += dep.base.actual;
+        acc.base.planned += dep.base.planned;
+        acc.baseDepartures.add(dep.departureId);
+        for (const [currency, res] of dep.residual) {
+            const entry = productResidual(acc, currency);
+            entry.revenue += res.revenue;
+            entry.actual += res.actual;
+            entry.planned += res.planned;
+        }
+    }
+    // Product-level allocations (cost attributed to a product, not a departure).
+    for (const row of productActualCost) {
+        if (query.currency && row.currency !== query.currency)
+            continue;
+        productBucket(ensureProduct(row.productId), row.currency).actual += row.amountCents;
+    }
+    for (const [productId, split] of productActualCostBase) {
+        const acc = ensureProduct(productId);
+        acc.base.actual += split.snapshotBase;
+        for (const [currency, amount] of split.residual) {
+            productResidual(acc, currency).actual += amount;
+        }
+    }
+    const rows = [];
+    for (const acc of products.values()) {
+        for (const [currency, totals] of acc.byCurrency) {
+            const revenueCents = Math.round(totals.revenue);
+            const actualCostCents = Math.round(totals.actual);
+            const plannedCostCents = Math.round(totals.planned);
+            const profitCents = revenueCents - actualCostCents;
+            rows.push({
+                productId: acc.productId,
+                productName: acc.productName,
+                currency,
+                departureCount: totals.departures.size,
+                revenueCents,
+                actualCostCents,
+                plannedCostCents,
+                profitCents,
+                marginPercent: margin(profitCents, revenueCents),
+                varianceCents: plannedCostCents - actualCostCents,
+            });
+        }
+    }
+    rows.sort((a, b) => a.productId.localeCompare(b.productId) || a.currency.localeCompare(b.currency));
+    const residualCurrencies = collectResidualCurrencies([...products.values()].flatMap((acc) => [...acc.residual.keys()]), costByServiceTypeBase, unattributedBase);
+    const { rates, unconvertible } = await buildBaseRates(db, residualCurrencies, baseCurrency, options);
+    const baseRows = [...products.values()]
+        .map((acc) => {
+        const totals = baseFromAcc(acc.base, acc.residual, rates);
+        const revenueCents = Math.round(totals.revenue);
+        const actualCostCents = Math.round(totals.actual);
+        const plannedCostCents = Math.round(totals.planned);
+        const profitCents = revenueCents - actualCostCents;
+        return {
+            productId: acc.productId,
+            productName: acc.productName,
+            currency: baseCurrency,
+            departureCount: acc.baseDepartures.size,
+            revenueCents,
+            actualCostCents,
+            plannedCostCents,
+            profitCents,
+            marginPercent: margin(profitCents, revenueCents),
+            varianceCents: plannedCostCents - actualCostCents,
+        };
+    })
+        .sort((a, b) => a.productId.localeCompare(b.productId));
+    return {
+        rows,
+        costByServiceType: filterCostByCurrency(costByServiceType, query.currency),
+        unattributed: filterCostByCurrency(unattributed, query.currency),
+        base: {
+            currency: baseCurrency,
+            rows: baseRows,
+            costByServiceType: baseCostByServiceType(costByServiceTypeBase, rates, baseCurrency),
+            unattributedCents: Math.round(resolveBaseSplit(unattributedBase, rates, new Set())),
+            unconvertibleCurrencies: unconvertible,
+        },
+    };
+}
+function filterCostByCurrency(rows, currency) {
+    return currency ? rows.filter((row) => row.currency === currency) : rows;
+}
+/**
+ * Derive per-traveller P&L for one departure in a single currency. Revenue is a
+ * booking's departure-attributed invoiced AR split equally across that booking's
+ * travellers; planned cost likewise; actual departure cost is split equally
+ * across all the departure's travellers (`equal` method — `per_pax` parity).
+ */
+export async function getTravelerProfitability(db, query) {
+    const departureId = query.departureId;
+    const currency = query.currency.toUpperCase();
+    const empty = { departureId, currency, travelerCount: 0, rows: [] };
+    const depItemRows = await db
+        .select({
+        bookingId: bookingItems.bookingId,
+        depSell: sql `coalesce(sum(${bookingItems.totalSellAmountCents}), 0)::bigint`,
+        depPlanned: sql `coalesce(sum(case when ${bookingItems.costCurrency} = ${currency} then ${bookingItems.totalCostAmountCents} else 0 end), 0)::bigint`,
+    })
+        .from(bookingItems)
+        .where(eq(bookingItems.availabilitySlotId, departureId))
+        .groupBy(bookingItems.bookingId);
+    const bookingIds = depItemRows.map((r) => r.bookingId);
+    if (bookingIds.length === 0)
+        return empty;
+    const [totalSellRows, invoiceRows, actualRows, travelerRows] = await Promise.all([
+        db
+            .select({
+            bookingId: bookingItems.bookingId,
+            totalSell: sql `coalesce(sum(${bookingItems.totalSellAmountCents}), 0)::bigint`,
+        })
+            .from(bookingItems)
+            .where(inArray(bookingItems.bookingId, bookingIds))
+            .groupBy(bookingItems.bookingId),
+        db
+            .select({
+            bookingId: invoices.bookingId,
+            total: sql `coalesce(sum(case when ${invoices.invoiceType} = 'credit_note' then -${invoices.totalCents} else ${invoices.totalCents} end), 0)::bigint`,
+        })
+            .from(invoices)
+            .where(and(inArray(invoices.bookingId, bookingIds), eq(invoices.currency, currency), ne(invoices.status, "void"), ne(invoices.status, "draft"), ne(invoices.invoiceType, "proforma")))
+            .groupBy(invoices.bookingId),
+        db
+            .select({
+            amount: sql `coalesce(sum(${supplierCostAllocations.amountCents}), 0)::bigint`,
+        })
+            .from(supplierCostAllocations)
+            .innerJoin(supplierInvoices, eq(supplierCostAllocations.supplierInvoiceId, supplierInvoices.id))
+            .where(and(eq(supplierCostAllocations.targetType, "departure"), eq(supplierCostAllocations.departureId, departureId), eq(supplierInvoices.currency, currency), ne(supplierInvoices.status, "void"), isNull(supplierInvoices.deletedAt))),
+        db
+            .select({
+            id: bookingTravelers.id,
+            bookingId: bookingTravelers.bookingId,
+            firstName: bookingTravelers.firstName,
+            lastName: bookingTravelers.lastName,
+        })
+            .from(bookingTravelers)
+            .where(and(inArray(bookingTravelers.bookingId, bookingIds), eq(bookingTravelers.participantType, "traveler"))),
+    ]);
+    const totalSellByBooking = new Map(totalSellRows.map((r) => [r.bookingId, num(r.totalSell)]));
+    const invoicedByBooking = new Map(invoiceRows.map((r) => [r.bookingId, num(r.total)]));
+    const depByBooking = new Map(depItemRows.map((r) => [
+        r.bookingId,
+        { depSell: num(r.depSell), depPlanned: num(r.depPlanned) },
+    ]));
+    const travelersByBooking = new Map();
+    for (const t of travelerRows) {
+        const list = travelersByBooking.get(t.bookingId) ?? [];
+        list.push({ id: t.id, name: `${t.firstName} ${t.lastName}`.trim() });
+        travelersByBooking.set(t.bookingId, list);
+    }
+    const travelerCount = travelerRows.length;
+    if (travelerCount === 0)
+        return empty;
+    const actualPerTraveler = num(actualRows[0]?.amount) / travelerCount;
+    const rows = [];
+    for (const bookingId of bookingIds) {
+        const travelers = travelersByBooking.get(bookingId);
+        if (!travelers || travelers.length === 0)
+            continue;
+        const dep = depByBooking.get(bookingId) ?? { depSell: 0, depPlanned: 0 };
+        const totalSell = totalSellByBooking.get(bookingId) ?? 0;
+        const ratio = totalSell > 0 ? dep.depSell / totalSell : 1;
+        const revenuePerTraveler = ((invoicedByBooking.get(bookingId) ?? 0) * ratio) / travelers.length;
+        const plannedPerTraveler = dep.depPlanned / travelers.length;
+        for (const traveler of travelers) {
+            const revenueCents = Math.round(revenuePerTraveler);
+            const actualCostCents = Math.round(actualPerTraveler);
+            const plannedCostCents = Math.round(plannedPerTraveler);
+            const profitCents = revenueCents - actualCostCents;
+            rows.push({
+                travelerId: traveler.id,
+                travelerName: traveler.name,
+                bookingId,
+                currency,
+                revenueCents,
+                actualCostCents,
+                plannedCostCents,
+                profitCents,
+                marginPercent: margin(profitCents, revenueCents),
+                varianceCents: plannedCostCents - actualCostCents,
+            });
+        }
+    }
+    rows.sort((a, b) => a.bookingId.localeCompare(b.bookingId) || a.travelerName.localeCompare(b.travelerName));
+    return { departureId, currency, travelerCount, rows };
+}
+// ---------- base-currency rollup (FX) ----------
+/** Distinct residual currencies that need a fallback conversion rate. */
+function collectResidualCurrencies(perRow, ...splits) {
+    const set = new Set(perRow);
+    for (const split of splits) {
+        if (split instanceof Map) {
+            for (const s of split.values())
+                for (const c of s.residual.keys())
+                    set.add(c);
+        }
+        else {
+            for (const c of split.residual.keys())
+                set.add(c);
+        }
+    }
+    return set;
+}
+/**
+ * Resolve a fallback conversion rate for each residual currency → base. Used ONLY
+ * for legacy rows that predate the base-amount snapshot (forward-only): persisted
+ * FX rate first (then the runtime resolver). No date is passed, so these use the
+ * latest available rate. Snapshotted rows never reach here — they are summed at
+ * their own issue-date rate. Currencies with no rate are reported as unconvertible
+ * and excluded from the rollup rather than guessed.
+ */
+async function buildBaseRates(db, currencies, base, options = {}) {
+    const rates = new Map();
+    const unconvertible = [];
+    for (const currency of new Set(currencies)) {
+        if (currency === base) {
+            rates.set(currency, 1);
+            continue;
+        }
+        const probeInput = { amountCents: 1_000_000, currency };
+        const probe = await resolveFxMoneyBaseAmount(db, probeInput, {
+            ...options,
+            targetBaseCurrency: base,
+        });
+        if (probe.baseAmountCents != null && probe.baseCurrency === base) {
+            rates.set(currency, probe.baseAmountCents / 1_000_000);
+        }
+        else {
+            unconvertible.push(currency);
+        }
+    }
+    return { rates, unconvertible };
+}
+/** Snapshot base + converted residuals → a single accounting-base figure set. */
+function baseFromAcc(snapshot, residual, rates) {
+    const out = {
+        revenue: snapshot.revenue,
+        actual: snapshot.actual,
+        planned: snapshot.planned,
+    };
+    for (const [currency, res] of residual) {
+        const rate = rates.get(currency);
+        if (rate == null)
+            continue;
+        out.revenue += res.revenue * rate;
+        out.actual += res.actual * rate;
+        out.planned += res.planned * rate;
+    }
+    return out;
+}
+/** Resolve the cost-by-category breakdown into the accounting base currency. */
+function baseCostByServiceType(splits, rates, base) {
+    const out = [];
+    for (const [serviceType, split] of splits) {
+        const amountCents = Math.round(resolveBaseSplit(split, rates, new Set()));
+        if (amountCents !== 0)
+            out.push({ serviceType, currency: base, amountCents });
+    }
+    return out;
+}
+// ---------- CSV export (accountant sharing) ----------
+const csvField = (value) => {
+    const str = value == null ? "" : String(value);
+    return /[",\n\r]/.test(str) ? `"${str.replace(/"/g, '""')}"` : str;
+};
+const csvRow = (cells) => cells.map(csvField).join(",");
+// BOM + CRLF so Excel opens UTF-8 correctly (mirrors availability exports).
+const csvDocument = (rows) => `${rows.join("\r\n")}\r\n`;
+const major = (cents) => (cents / 100).toFixed(2);
+const marginCell = (value) => (value == null ? "" : value.toFixed(1));
+export function buildDepartureProfitabilityCsv(report) {
+    const header = [
+        "departure_id",
+        "departure",
+        "product_id",
+        "product",
+        "date",
+        "currency",
+        "revenue",
+        "actual_cost",
+        "planned_cost",
+        "profit",
+        "margin_percent",
+        "variance",
+    ];
+    const rows = report.rows.map((r) => csvRow([
+        r.departureId,
+        r.departureLabel,
+        r.productId,
+        r.productName,
+        r.departureDate,
+        r.currency,
+        major(r.revenueCents),
+        major(r.actualCostCents),
+        major(r.plannedCostCents),
+        major(r.profitCents),
+        marginCell(r.marginPercent),
+        major(r.varianceCents),
+    ]));
+    return csvDocument([csvRow(header), ...rows]);
+}
+export function buildProductProfitabilityCsv(report) {
+    const header = [
+        "product_id",
+        "product",
+        "currency",
+        "departures",
+        "revenue",
+        "actual_cost",
+        "planned_cost",
+        "profit",
+        "margin_percent",
+        "variance",
+    ];
+    const rows = report.rows.map((r) => csvRow([
+        r.productId,
+        r.productName,
+        r.currency,
+        r.departureCount,
+        major(r.revenueCents),
+        major(r.actualCostCents),
+        major(r.plannedCostCents),
+        major(r.profitCents),
+        marginCell(r.marginPercent),
+        major(r.varianceCents),
+    ]));
+    return csvDocument([csvRow(header), ...rows]);
+}