@curless/hotel-storefront 0.50.4 → 0.51.0

package/dist/demo-hotels.js

@@ -103,6 +103,16 @@ const wholeBooking = (b) => {
         x.quote.lines.every((l) => !!l && typeof l.hotelId === 'string' && isMoney(l.total)) &&
         isMoney(x.quote?.total));
 };
+/**
+ * A member's whole name: given then surname - or, in a script that puts the
+ * surname first, that way round with no space. "小雨 林" was 林小雨 written
+ * backwards (10-30, the Atour member screenshots).
+ */
+/** "A, B or C" - for what a coupon is limited to. */
+const listOr = (xs) => xs.length > 1 ? `${xs.slice(0, -1).join(', ')} or ${xs.at(-1)}` : (xs[0] ?? '');
+export const fullName = (given, surname) => /[\p{Script=Han}\p{Script=Hangul}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(given + surname)
+    ? `${surname.trim()}${given.trim()}`
+    : `${given.trim()} ${surname.trim()}`;
 const publicBooking = (b) => {
     const { owners, askedAs, ...rest } = b;
     void owners;
@@ -217,6 +227,13 @@ export const createDemoHotels = (opts) => {
     const rng = opts.rng ?? (() => randomInt(0, 2 ** 32) / 2 ** 32);
     const holdMs = opts.holdMs ?? HOLD_MS_DEFAULT;
     const bookings = new Map();
+    /**
+     * The held coupons spent on a booking, by held id (upper case): the booking
+     * it went on. Kept apart from the bookings because a booking is forgotten
+     * some days after its stay, and a coupon spent on it must not come back then.
+     * Given back by `giveBack` when the booking is cancelled or lapses in time.
+     */
+    const spent = new Map();
     /** One booking request at a time per conversation and per email - see `singleFlight`. */
     const single = singleFlight();
     /** Saved room preferences, by membership number - see `preferencesFor`. */
@@ -270,9 +287,14 @@ export const createDemoHotels = (opts) => {
         if (typeof number === 'string' && Array.isArray(kinds))
             preferences.set(number, kinds);
     }
+    for (const [held, booking] of saved?.couponsSpent ?? []) {
+        if (typeof held === 'string' && typeof booking === 'string')
+            spent.set(held.toUpperCase(), booking);
+    }
     opts.state?.bind(() => ({
         bookings: [...bookings.values()].map((b) => ({ ...b, owners: [...b.owners] })),
         preferences: [...preferences],
+        couponsSpent: [...spent],
     }));
     const changed = () => opts.state?.changed();
     /**
@@ -310,16 +332,22 @@ export const createDemoHotels = (opts) => {
         if (!m)
             return null;
         const wanted = number.replace(/\s+/g, '').toUpperCase();
+        const said = surname.trim().toLowerCase();
+        // The surname as it is printed in any script the programme holds it in:
+        // 林 as well as Lin (10-30: a Chinese guest types 林).
         const hit = m.members.find((x) => x.number.replace(/\s+/g, '').toUpperCase() === wanted &&
-            x.surname.trim().toLowerCase() === surname.trim().toLowerCase());
+            [x.surname, ...Object.values(x.names ?? {}).map((n) => n.surname)].some((n) => n.trim().toLowerCase() === said));
         if (!hit)
             return null;
         const tier = m.tiers.find((t) => t.id === hit.tier);
         if (!tier)
             return null;
+        const names = Object.fromEntries(Object.entries(hit.names ?? {}).map(([lang, n]) => [lang, fullName(n.given, n.surname)]));
+        const coupons = heldCouponsOf(hit);
         return {
             number: hit.number,
-            name: `${hit.given} ${hit.surname}`,
+            name: fullName(hit.given, hit.surname),
+            ...(Object.keys(names).length ? { names } : {}),
             surname: hit.surname,
             programme: m.programme,
             tier: {
@@ -329,8 +357,71 @@ export const createDemoHotels = (opts) => {
                 pointsPerUnit: tier.pointsPerUnit,
             },
             points: hit.points,
+            ...(hit.pointsExpiring ? { pointsExpiring: { ...hit.pointsExpiring } } : {}),
+            // An empty list where the programme gives coupons out: "holds none" is
+            // not "takes none", and the card says the one, not the other.
+            ...(couponKinds.size ? { coupons } : {}),
         };
     };
+    /** The programme's coupon kinds, by id. */
+    const couponKinds = new Map((opts.data.membership?.coupons ?? []).map((c) => [c.id, c]));
+    /** A held coupon as the member sees it, on `today` - see `HeldCoupon`. */
+    const heldCoupon = (held, todayIs) => {
+        const kind = couponKinds.get(held.coupon);
+        if (!kind)
+            return undefined;
+        const cur = kind.currency;
+        const amount = (x) => x === undefined ? undefined : money(toMinor(x, cur), cur);
+        const brandNames = (b) => hotels.find((h) => h.brand === b)?.names?.brand;
+        return {
+            id: held.id,
+            kind: kind.kind,
+            name: kind.name,
+            ...(kind.names ? { names: kind.names } : {}),
+            ...(kind.amountOff !== undefined ? { amountOff: amount(kind.amountOff) } : {}),
+            ...(kind.percentOff !== undefined ? { percentOff: kind.percentOff } : {}),
+            ...(kind.maxOff !== undefined ? { maxOff: amount(kind.maxOff) } : {}),
+            ...(kind.minSpend ? { minSpend: amount(kind.minSpend) } : {}),
+            ...(kind.brands
+                ? {
+                    brands: kind.brands.map((b) => ({
+                        name: b,
+                        ...(brandNames(b) ? { names: brandNames(b) } : {}),
+                    })),
+                }
+                : {}),
+            ...(kind.hotels
+                ? {
+                    hotels: kind.hotels.flatMap((id) => {
+                        const h = hotels.find((x) => x.id === id);
+                        return h
+                            ? [{ id, name: h.name, ...(h.names?.name ? { names: h.names.name } : {}) }]
+                            : [];
+                    }),
+                }
+                : {}),
+            validFrom: held.validFrom,
+            validUntil: held.validUntil,
+            state: spent.has(held.id.toUpperCase())
+                ? 'used'
+                : todayIs > held.validUntil
+                    ? 'expired'
+                    : todayIs < held.validFrom
+                        ? 'not-yet'
+                        : 'usable',
+        };
+    };
+    /** A member's coupons as they stand, usable first, then by when they run out. */
+    const heldCouponsOf = (raw) => {
+        const order = { usable: 0, 'not-yet': 1, used: 2, expired: 3 };
+        return (raw.coupons ?? [])
+            .flatMap((c) => heldCoupon(c, todayAt(now(), DEFAULT_OFFSET)) ?? [])
+            .sort((a, b) => order[a.state] - order[b.state] || a.validUntil.localeCompare(b.validUntil));
+    };
+    /** The member's own record - what their coupons are read from, live. */
+    const rawMember = (m) => m
+        ? opts.data.membership?.members.find((x) => x.number.toUpperCase() === m.number.toUpperCase())
+        : undefined;
     /** The tier's discount, or none. One place, so a rate cannot be discounted twice. */
     const discountOf = (who) => who?.member?.tier.discount ?? 0;
     /**
@@ -405,12 +496,29 @@ export const createDemoHotels = (opts) => {
             }
             else if (b.status === 'requested' && b.holdUntil && Date.parse(b.holdUntil) <= t) {
                 b.status = 'expired';
+                giveBack(b, Date.parse(b.holdUntil));
                 dirty = true;
             }
         }
         if (dirty)
             changed();
     };
+    /**
+     * A booking that ended - cancelled, or a hold that lapsed - hands its coupon
+     * back while the coupon is in its dates on the hotel's calendar; once it has
+     * run out, it stays spent (§2). Said on the booking either way.
+     */
+    const giveBack = (b, at = now()) => {
+        const c = b.quote.coupon;
+        if (!c || spent.get(c.id.toUpperCase()) !== b.id)
+            return;
+        // On the day it ended - a lapse noticed days later lapsed when its hold did.
+        const h = byId(b.hotelId);
+        const returned = todayAt(at, h ? offsetOf(h) : DEFAULT_OFFSET) <= c.validUntil;
+        if (returned)
+            spent.delete(c.id.toUpperCase());
+        b.couponReturned = returned;
+    };
     /** Room-nights the live holds that `pick` chooses take, leaving out `ignore`. */
     const heldBy = (pick, ignore) => [...bookings.values()]
         .filter((b) => b.status === 'requested' && b.id !== ignore && pick(b))
@@ -880,11 +988,15 @@ export const createDemoHotels = (opts) => {
         const member = who?.member;
         // Every line's tax is already a whole unit - see `taxOn`.
         const taxed = taxes;
+        const { coupons, coupon, couponRefused } = couponsFor(trip.coupon, member, lines, cur);
+        // The coupon comes off the all-in total, after the tier (§2): what is
+        // paid at the hotel, and what points are earned on.
+        const paid = subtotal + taxed - (coupon?.off.minor ?? 0);
         return {
             lines,
             subtotal: money(subtotal, cur),
             taxesAndFees: money(taxed, cur),
-            total: money(subtotal + taxed, cur),
+            total: money(paid, cur),
             stay,
             dropped: dropped.length ? dropped : undefined,
             ...(member && lines.length
@@ -896,10 +1008,176 @@ export const createDemoHotels = (opts) => {
                         // Points on what is actually paid, converted to the programme's
                         // own currency first. See RawEarn: without the conversion this
                         // line pays a Jakarta guest two thousand times a Paris one.
-                        points: Math.round(((subtotal + taxed) / minorFactor(cur) / earnRate(cur)) * member.tier.pointsPerUnit),
+                        points: Math.round((paid / minorFactor(cur) / earnRate(cur)) * member.tier.pointsPerUnit),
+                        publicTotal: money(subtotal + taxed + saved, cur),
                     },
                 }
                 : {}),
+            ...(coupon ? { coupon } : {}),
+            ...(couponRefused ? { couponRefused } : {}),
+            ...(coupons ? { coupons } : {}),
+        };
+    };
+    /**
+     * What a coupon takes off a stay that comes to `base` (minor units, all in at
+     * the member rate): an amount, or a fraction rounded DOWN to the whole unit
+     * and capped - never more than the stay (§2).
+     */
+    const offOf = (kind, base) => {
+        const cur = kind.currency;
+        const off = kind.kind === 'amount-off'
+            ? toMinor(kind.amountOff ?? 0, cur)
+            : Math.min(Math.floor((base * (kind.percentOff ?? 0)) / minorFactor(cur)) * minorFactor(cur), kind.maxOff === undefined ? Number.POSITIVE_INFINITY : toMinor(kind.maxOff, cur));
+        return Math.max(0, Math.min(off, base));
+    };
+    /**
+     * The member's coupons against these priced lines, and the one asked for.
+     *
+     * ⚠️ ONE STAY TAKES IT. A stay - one hotel's rooms for the same nights - is
+     * one booking, and a coupon is spent on one booking: the stay it takes off
+     * most (the first, on a tie). Its minimum is that stay's rooms all in at the
+     * member rate; add-ons are not rooms and do not count. Two or three rooms of
+     * one stay are one stay: taken off once.
+     */
+    const couponsFor = (asked, member, lines, cur) => {
+        const raw = rawMember(member);
+        if (!couponKinds.size) {
+            return asked
+                ? {
+                    couponRefused: {
+                        id: asked,
+                        code: 'not-held',
+                        why: 'Coupons are not taken here.',
+                    },
+                }
+                : {};
+        }
+        const stays = [];
+        for (const l of lines) {
+            if (l.kind !== 'room' || !l.stay)
+                continue;
+            const h = byId(l.hotelId);
+            if (!h)
+                continue;
+            const key = `${h.id}|${l.stay.checkIn}|${l.stay.checkOut}`;
+            const at = stays.find((x) => x.key === key);
+            const all = (l.totalWithTaxes ?? l.total).minor;
+            if (at)
+                at.base += all;
+            else
+                stays.push({
+                    key,
+                    hotel: h,
+                    checkIn: l.stay.checkIn,
+                    checkOut: l.stay.checkOut,
+                    base: all,
+                });
+        }
+        const said = (minor, c) => formatMoney(money(minor, c));
+        const options = [];
+        for (const held of raw?.coupons ?? []) {
+            const kind = couponKinds.get(held.coupon);
+            // Its dates on the calendar of the hotel it would go on - all of them
+            // are on one clock in this demonstration, so the trip's first.
+            const c = kind && heldCoupon(held, today(stays[0]?.hotel.id));
+            if (!kind || !c)
+                continue;
+            const no = (code, why, more = {}) => options.push({ ...c, code, why, ...more });
+            if (c.state === 'used') {
+                no('used', 'It has already been used on a booking.');
+                continue;
+            }
+            if (c.state === 'expired') {
+                no('expired', `It ran out on ${c.validUntil}.`);
+                continue;
+            }
+            if (c.state === 'not-yet') {
+                no('not-yet', `It can be used from ${c.validFrom}.`);
+                continue;
+            }
+            if (!stays.length) {
+                no('no-room', 'The trip has no room for it to come off.');
+                continue;
+            }
+            const inCur = stays.filter((x) => x.hotel.currency.toUpperCase() === kind.currency);
+            if (!inCur.length) {
+                no('currency', `It is in ${kind.currency}, and this trip is priced in ${cur}.`);
+                continue;
+            }
+            const fits = inCur.filter((x) => (!kind.brands || kind.brands.includes(x.hotel.brand)) &&
+                (!kind.hotels || kind.hotels.includes(x.hotel.id)));
+            if (!fits.length) {
+                no('scope', kind.hotels
+                    ? `It is only for ${listOr(kind.hotels.map((id) => byId(id)?.name ?? id))}.`
+                    : `It is only for ${listOr(kind.brands ?? [])} hotels.`);
+                continue;
+            }
+            const min = toMinor(kind.minSpend ?? 0, kind.currency);
+            const big = fits.filter((x) => x.base >= min);
+            if (!big.length) {
+                const most = Math.max(...fits.map((x) => x.base));
+                no('min-spend', `It needs a stay of ${said(min, kind.currency)} or more, and ${fits.length > 1 ? 'the largest stay it is for' : 'the stay'} comes to ${said(most, kind.currency)}.`, { minSpend: money(min, kind.currency), spend: money(most, kind.currency) });
+                continue;
+            }
+            const best = big.reduce((a, b) => (offOf(kind, b.base) > offOf(kind, a.base) ? b : a));
+            options.push({
+                ...c,
+                off: money(offOf(kind, best.base), kind.currency),
+                hotelId: best.hotel.id,
+                hotelName: best.hotel.name,
+                ...(best.hotel.names?.name ? { hotelNames: best.hotel.names.name } : {}),
+                stay: best,
+            });
+        }
+        // Usable here first, the one that takes most off at the top - then the rest
+        // in the member's own order.
+        const ranked = [...options].sort((a, b) => (b.off?.minor ?? -1) - (a.off?.minor ?? -1));
+        const coupons = raw ? ranked.map(({ stay: _s, ...o }) => o) : undefined;
+        if (!asked)
+            return coupons ? { coupons } : {};
+        const wanted = asked.trim().toUpperCase();
+        const o = options.find((x) => x.id.toUpperCase() === wanted);
+        const refused = (r) => ({
+            ...(coupons ? { coupons } : {}),
+            couponRefused: r,
+        });
+        if (!member)
+            return refused({
+                id: asked,
+                code: 'signed-out',
+                why: "Nobody is signed in, and a coupon is a member's: sign in first.",
+            });
+        if (!o)
+            return refused({
+                id: asked,
+                code: 'not-held',
+                why: `${member.name} holds no coupon ${asked}.`,
+            });
+        if (!o.off || !o.stay)
+            return refused({
+                id: o.id,
+                name: o.name,
+                ...(o.names ? { names: o.names } : {}),
+                code: o.code ?? 'scope',
+                why: o.why ?? 'It cannot be used on this trip.',
+                ...(o.minSpend && o.code === 'min-spend' ? { minSpend: o.minSpend } : {}),
+                ...(o.spend ? { spend: o.spend } : {}),
+            });
+        return {
+            ...(coupons ? { coupons } : {}),
+            coupon: {
+                id: o.id,
+                name: o.name,
+                ...(o.names ? { names: o.names } : {}),
+                kind: o.kind,
+                off: o.off,
+                hotelId: o.stay.hotel.id,
+                hotelName: o.stay.hotel.name,
+                ...(o.stay.hotel.names?.name ? { hotelNames: o.stay.hotel.names.name } : {}),
+                checkIn: o.stay.checkIn,
+                checkOut: o.stay.checkOut,
+                validUntil: o.validUntil,
+            },
         };
     };
     /**
@@ -959,9 +1237,14 @@ export const createDemoHotels = (opts) => {
         const subtotal = lines.reduce((n, l) => n + l.total.minor, 0);
         const taxes = rooms.reduce((n, l) => n + roomTaxOf(l, taxRate), 0) +
             extras.reduce((n, l) => n + wholeUnits(taxOn(l.total, taxRate)).minor, 0);
-        const total = subtotal + taxes;
-        const { dropped, member, ...rest } = was;
+        // The coupon the rooms were booked with stays off: it went on the rooms,
+        // and they are kept as booked.
+        const off = was.coupon?.off.minor ?? 0;
+        const total = subtotal + taxes - off;
+        const { dropped, member, coupons, couponRefused, ...rest } = was;
         void dropped;
+        void coupons;
+        void couponRefused;
         return {
             ...rest,
             lines,
@@ -976,6 +1259,7 @@ export const createDemoHotels = (opts) => {
                         points: was.total.minor
                             ? Math.round((member.points * total) / was.total.minor)
                             : member.points,
+                        publicTotal: money(total + off + member.saved.minor, cur),
                     },
                 }
                 : {}),
@@ -1047,6 +1331,10 @@ export const createDemoHotels = (opts) => {
             : undefined;
         if (locked)
             return no(`${locked.title} is a non-refundable rate: it cannot be cancelled or changed. Book the new nights as their own stay - this one stands.`);
+        // A coupon was worked out on these nights and rooms (§2): moved, it would
+        // have to be worked out again, and may no longer apply. Not in place yet.
+        if (b.quote.coupon && movesRooms)
+            return no(`This booking used the coupon ${b.quote.coupon.name}, and a booking made with a coupon cannot be moved in place yet: cancel it (the coupon comes back while it is in its dates) and book the new nights.`);
         // "No rooms" is not a smaller booking. It became one room without a word.
         if (change.rooms !== undefined && !(Math.floor(change.rooms) >= 1))
             return no('A booking keeps at least one room. To give them all back, cancel it instead.');
@@ -1203,7 +1491,24 @@ export const createDemoHotels = (opts) => {
         if (b.quote.lines.some((l) => l.kind === 'extra')) {
             rules.push('Add-ons are dropped at no charge.');
         }
-        return { fee: money(fee, currency), rules, freeUntil };
+        const capped = couponCap(b, fee);
+        if (capped < fee)
+            rules.push(`The coupon took ${formatMoney(b.quote.coupon?.off ?? money(0, currency))} off this stay, so the fee is at most what the stay comes to.`);
+        return { fee: money(capped, currency), rules, freeUntil };
+    };
+    /**
+     * A fee never above what the stay came to: a coupon took money off the
+     * rooms, and a whole non-refundable stay charged at its price before the
+     * coupon was ¥604 on a booking of ¥554 (0.51.0).
+     */
+    const couponCap = (b, fee) => {
+        const off = b.quote.coupon?.off.minor;
+        if (!off)
+            return fee;
+        const rooms = b.quote.lines
+            .filter((l) => l.kind === 'room')
+            .reduce((n, l) => n + (l.totalWithTaxes ?? l.total).minor, 0);
+        return Math.min(fee, Math.max(0, rooms - off));
     };
     /**
      * The same terms as `feeFor` works them out, as steps in time
@@ -1225,7 +1530,7 @@ export const createDemoHotels = (opts) => {
             ? Date.parse(line.freeCancellationUntil)
             : Number.NaN;
         const inFree = !Number.isNaN(freeUntil) && at <= freeUntil;
-        const after = money(line.refundable ? oneNightOf(line, taxRate) : wholeStayOf(line, taxRate), currency);
+        const after = money(couponCap(b, line.refundable ? oneNightOf(line, taxRate) : wholeStayOf(line, taxRate)), currency);
         const terms = [
             ...(Number.isNaN(freeUntil)
                 ? []
@@ -1261,6 +1566,8 @@ export const createDemoHotels = (opts) => {
             ...FULL_CAPABILITIES,
             ...opts.capabilities,
             ...(opts.data.membership ? { programme: opts.data.membership.programme } : {}),
+            // Coupons where the programme gives some out, and members can sign in.
+            ...(couponKinds.size && opts.capabilities?.members !== false ? { coupons: true } : {}),
             codePrefix,
         },
         today,
@@ -1726,6 +2033,8 @@ export const createDemoHotels = (opts) => {
         },
         quote: quoteTrip,
         async signInMember(number, surname) {
+            // A hold that lapsed hands its coupon back - before the coupons are read.
+            sweep();
             const member = memberFor(number, surname);
             if (!member)
                 return null;
@@ -1788,7 +2097,10 @@ export const createDemoHotels = (opts) => {
             const email = guest.email.trim().toLowerCase();
             const conversation = conversationOf(who);
             const locks = [...new Set([who.sessionId, conversation])].map((k) => `s:${k}`);
-            return single([...locks, `e:${email}`], async () => {
+            // ⚠️ AND ONE AT A TIME PER MEMBER, when a coupon is spent: two
+            // conversations signed in as one member would each find it unspent.
+            const holder = trip.coupon && who.member ? [`m:${who.member.number.toUpperCase()}`] : [];
+            return single([...locks, `e:${email}`, ...holder], async () => {
                 // ⚠️ THE SAME STAY ASKED FOR AGAIN IS ANSWERED WITH THE FIRST. A stay is
                 // the same when its rooms, nights, party, hours and add-ons are, and the
                 // guest is - name, phone, requests and arrival, NOT the note (free text,
@@ -1819,6 +2131,28 @@ export const createDemoHotels = (opts) => {
                 if (reused.length && !fresh.length) {
                     return { booked: reused.map(publicBooking), failed: [], repeat: true };
                 }
+                // ⚠️ THE COUPON ASKED FOR, OR NOTHING. The guest agreed to a price with
+                // it; booked without it they would pay more than they were told. Not
+                // when it already went on a stay asked for minutes before (`reused`).
+                const wantCoupon = trip.coupon?.trim().toUpperCase();
+                const couponDone = reused.some((b) => b.quote.coupon?.id.toUpperCase() === wantCoupon);
+                let couponAt;
+                if (wantCoupon && !couponDone) {
+                    const whole = await quoteTrip({ lines: fresh.flatMap((f) => f.lines), coupon: trip.coupon }, who);
+                    if (whole.couponRefused) {
+                        throw demoError('coupon', `Nothing was booked. The coupon ${whole.couponRefused.name ?? whole.couponRefused.id} cannot be used: ${whole.couponRefused.why} Book without it only if the guest says so.`);
+                    }
+                    const c = whole.coupon;
+                    couponAt = c ? `${c.hotelId}|${c.checkIn}|${c.checkOut}` : undefined;
+                }
+                /** The coupon for this stay's own quote - the one stay it goes on. */
+                const couponFor = (g) => {
+                    const r = g.find((l) => l.kind === 'room');
+                    const h = r && byId(r.hotelId);
+                    return couponAt && r && h && `${h.id}|${r.stay.checkIn}|${r.stay.checkOut}` === couponAt
+                        ? { coupon: trip.coupon }
+                        : {};
+                };
                 // ⚠️ EACH STAY ON ITS OWN, AND WHAT WAS BOOKED IS KEPT (robin,
                 // 2026-10-14 - see the seam). A stay that cannot be booked is said, with
                 // why, and stays in the trip; the others are booked. It used to be all or
@@ -1845,7 +2179,7 @@ export const createDemoHotels = (opts) => {
                 const priced = await Promise.all(fresh.map(async ({ lines: g, key }) => ({
                     lines: g,
                     key,
-                    quote: await quoteTrip({ lines: g }, who),
+                    quote: await quoteTrip({ lines: g, ...couponFor(g) }, who),
                 })));
                 const bookable = priced.filter(({ lines, quote }) => {
                     const ok = !quote.dropped?.length && quote.lines.some((l) => l.kind === 'room');
@@ -1867,13 +2201,18 @@ export const createDemoHotels = (opts) => {
                 // One at a time, in date order: each is held as it is made, so a later
                 // stay of this same trip sees the rooms an earlier one took.
                 for (const { lines: g, key } of bookable) {
-                    const quote = await quoteTrip({ lines: g }, who);
+                    const quote = await quoteTrip({ lines: g, ...couponFor(g) }, who);
                     const [firstRoom] = quote.lines.filter((l) => l.kind === 'room');
                     const h = firstRoom ? byId(firstRoom.hotelId) : undefined;
                     if (!firstRoom || !h || !quote.stay || quote.dropped?.length) {
                         failed.push(failedFor(g, quote));
                         continue;
                     }
+                    // Never booked without the coupon it was meant to carry.
+                    if (quote.couponRefused) {
+                        failed.push(failedFor(g, quote, `The coupon could not be used: ${quote.couponRefused.why}`));
+                        continue;
+                    }
                     const arrival = arrivalInstant(quote.stay.checkIn, h.checkInFrom ?? '15:00', offsetOf(h));
                     const holdUntil = new Date(Math.max(t + 3_600_000, Math.min(t + holdMs, arrival - HOLD_STOPS_BEFORE_ARRIVAL_MS))).toISOString();
                     const booking = {
@@ -1896,6 +2235,8 @@ export const createDemoHotels = (opts) => {
                         askedAs: key,
                     };
                     bookings.set(booking.id, booking);
+                    if (quote.coupon)
+                        spent.set(quote.coupon.id.toUpperCase(), booking.id);
                     made.push(booking);
                 }
                 if (made.length)
@@ -1996,6 +2337,17 @@ export const createDemoHotels = (opts) => {
                 freeUntil,
                 cancellable,
                 ...(steps ? { steps } : {}),
+                ...(cancellable && b.quote.coupon
+                    ? {
+                        coupon: {
+                            id: b.quote.coupon.id,
+                            name: b.quote.coupon.name,
+                            ...(b.quote.coupon.names ? { names: b.quote.coupon.names } : {}),
+                            validUntil: b.quote.coupon.validUntil,
+                            returned: today(b.hotelId) <= b.quote.coupon.validUntil,
+                        },
+                    }
+                    : {}),
             };
         },
         async cancelBooking(bookingRef, who, reason) {
@@ -2009,6 +2361,7 @@ export const createDemoHotels = (opts) => {
             b.status = 'cancelled';
             b.cancelledAt = new Date(now()).toISOString();
             b.cancellationFee = fee;
+            giveBack(b);
             const why = reason?.replace(/\s+/g, ' ').trim().slice(0, REASON_MAX);
             if (why)
                 b.guest = {