@curless/hotel-storefront 0.18.3 → 0.19.0

package/dist/demo-hotels.js

@@ -1,3 +1,4 @@
+import { randomInt, randomUUID } from 'node:crypto';
 import { LASTING_REQUESTS, MAX_PAGE, REQUEST_KINDS, REQUEST_NOTE_MAX } from './backend.js';
 import { addDays, arrivalInstant, eachNight, isWeekendNight, nights as nightsBetween, stayProblem, todayAt, } from './dates.js';
 import { FACILITIES, hasFacility } from './facilities.js';
@@ -31,6 +32,25 @@ const HOLD_STOPS_BEFORE_ARRIVAL_MS = 2 * 3_600_000;
 const CODE_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
 /** Only ever used for an empty trip, which has no hotel to take a currency from. */
 const DEFAULT_CURRENCY = 'HKD';
+/** Conversations one booking can be opened from - its own, and a few that found it. */
+const MAX_OWNERS = 10;
+/**
+ * Bookings kept at once. Past it, the oldest that are over - cancelled, lapsed,
+ * or checked out - are forgotten first. A live hold is never dropped to make
+ * room: it is a room somebody was promised.
+ */
+const MAX_BOOKINGS = 5_000;
+/**
+ * Live holds one conversation may have at once. A demo's inventory is shared:
+ * one conversation asking over and over would take every room off every guest
+ * for the two hours the holds last.
+ */
+export const MAX_HOLDS_PER_CONVERSATION = 10;
+const publicBooking = (b) => {
+    const { owners, ...rest } = b;
+    void owners;
+    return { ...rest };
+};
 /**
  * A trip cut into the stays a hotel would confirm one by one: the rooms at one
  * hotel for the same nights, and the add-ons bought for those nights.
@@ -71,12 +91,14 @@ export const splitByStay = (lines) => {
 export const createDemoHotels = (opts) => {
     const hotels = opts.data.hotels;
     const now = opts.now ?? (() => Date.now());
-    const rng = opts.rng ?? Math.random;
+    // ⚠️ A CODE IS HALF OF WHAT OPENS A BOOKING, so it comes from the crypto
+    // generator: Math.random is predictable from its own output. Tests inject
+    // their own.
+    const rng = opts.rng ?? (() => randomInt(0, 2 ** 32) / 2 ** 32);
     const holdMs = opts.holdMs ?? HOLD_MS_DEFAULT;
     const bookings = new Map();
     /** Saved room preferences, by membership number - see `preferencesFor`. */
     const preferences = new Map();
-    let seq = 0;
     const byId = (id) => {
         const wanted = id.trim().toLowerCase();
         return (hotels.find((h) => h.id.toLowerCase() === wanted) ??
@@ -185,6 +207,22 @@ export const createDemoHotels = (opts) => {
                 b.status = 'expired';
         }
     };
+    /**
+     * Until when this room on these nights can be cancelled for nothing - or
+     * nothing, when it cannot.
+     *
+     * ⚠️ A WINDOW THAT HAS ALREADY CLOSED IS NO WINDOW. A stay two days out on a
+     * 48-hour rule was listed as "Free cancellation", compared as "Yes" and
+     * described as "free to cancel until" yesterday - and booked, it cost a
+     * night to cancel (2026-09-28 audit).
+     */
+    const freeUntilOf = (h, r, stay) => {
+        if (!r.refundable || r.freeCancelHours === undefined)
+            return undefined;
+        const at = arrivalInstant(stay.checkIn, h.checkInFrom ?? '15:00', offsetOf(h)) -
+            r.freeCancelHours * 3_600_000;
+        return at > now() ? new Date(at).toISOString() : undefined;
+    };
     const priceRoom = (h, r, stay, who, 
     /** A booking whose own rooms do not count against it — see `heldOn`. */
     ignore) => {
@@ -199,10 +237,7 @@ export const createDemoHotels = (opts) => {
             : publicSubtotal;
         const taxes = wholeUnits(taxOn(roomSubtotal, h.taxRate));
         const publicTaxes = wholeUnits(taxOn(publicSubtotal, h.taxRate));
-        const freeUntil = r.refundable && r.freeCancelHours !== undefined
-            ? new Date(arrivalInstant(stay.checkIn, h.checkInFrom ?? '15:00', offsetOf(h)) -
-                r.freeCancelHours * 3_600_000).toISOString()
-            : undefined;
+        const freeUntil = freeUntilOf(h, r, stay);
         return {
             id: r.id,
             name: r.name,
@@ -312,13 +347,50 @@ export const createDemoHotels = (opts) => {
             if (!inUse(`SL-${out}${n}`))
                 return `SL-${out}${n}`;
     };
-    const mine = (b, who) => b.sessionId === who.sessionId ||
-        (!!who.email && b.guest.email.toLowerCase() === who.email.toLowerCase());
-    /** One booking by its id or the code a guest quotes, and only if it is theirs. */
+    /**
+     * One booking by its id or the code a guest quotes, and only if it is theirs:
+     * this conversation's, or found with its code and the email it was made with.
+     *
+     * ⚠️ WITH AN EMAIL, THE CODE AND ONLY THE CODE. The id was accepted too, and
+     * it was `bk_<the time>_<a counter>` - an email and a few dozen guesses
+     * opened somebody's booking (2026-09-28 audit). Ids are random now, and
+     * still not taken with an email: the code is what the guest was given.
+     *
+     * Found that way, the booking is this conversation's from then on - see
+     * `StoredBooking`.
+     */
     const findBooking = (ref, who) => {
         const wanted = ref.trim().toLowerCase();
-        return [...bookings.values()].find((x) => (x.id.toLowerCase() === wanted || x.confirmationCode.toLowerCase() === wanted) &&
-            mine(x, who));
+        if (!wanted)
+            return undefined;
+        const own = [...bookings.values()].find((x) => x.owners.has(who.sessionId) &&
+            (x.id.toLowerCase() === wanted || x.confirmationCode.toLowerCase() === wanted));
+        if (own || !who.email)
+            return own;
+        const email = who.email.trim().toLowerCase();
+        const there = [...bookings.values()].find((x) => x.confirmationCode.toLowerCase() === wanted && x.guest.email.trim().toLowerCase() === email);
+        if (there) {
+            there.owners.add(who.sessionId);
+            while (there.owners.size > MAX_OWNERS) {
+                const [, second] = [...there.owners];
+                // The conversation that made it stays; the oldest finder goes.
+                if (second === undefined)
+                    break;
+                there.owners.delete(second);
+            }
+        }
+        return there;
+    };
+    /** Over and done with - nothing held, nothing left to change. */
+    const ended = (b) => (b.status !== 'requested' && b.status !== 'confirmed') || b.stay.checkOut < today(b.hotelId);
+    /** Room for one more, by forgetting the oldest booking that is over. */
+    const makeRoom = (incoming) => {
+        for (const b of [...bookings.values()]) {
+            if (bookings.size + incoming <= MAX_BOOKINGS)
+                return;
+            if (ended(b))
+                bookings.delete(b.id);
+        }
     };
     /** A room type by its id or the name the hotel prints. */
     const roomOf = (h, ref) => {
@@ -441,7 +513,8 @@ export const createDemoHotels = (opts) => {
             const units = extraUnits(rawExtra, stay, line.quantity);
             const total = multiplyMoney(extra.price, units);
             subtotal += total.minor;
-            taxes += taxOn(total, h.taxRate).minor;
+            // Each add-on's tax rounded on its own, like each room's - see `taxOn`.
+            taxes += wholeUnits(taxOn(total, h.taxRate)).minor;
             lines.push({
                 kind: 'extra',
                 hotelId: h.id,
@@ -473,9 +546,8 @@ export const createDemoHotels = (opts) => {
             }
             : undefined;
         const member = who?.member;
-        // Rounded once, here, to the whole unit - see `wholeUnits`. The rooms' own
-        // tax already is; the add-ons' is added up first and rounded with it.
-        const taxed = wholeUnits(money(taxes, cur)).minor;
+        // Every line's tax is already a whole unit - see `taxOn`.
+        const taxed = taxes;
         return {
             lines,
             subtotal: money(subtotal, cur),
@@ -528,6 +600,55 @@ export const createDemoHotels = (opts) => {
             };
         });
     };
+    /**
+     * The tax on one stored room line, exactly as it was charged: `priceRoom`
+     * rounds each room's tax to the whole unit, and a line is that room times
+     * how many.
+     */
+    const roomTaxOf = (l, taxRate) => {
+        const q = Math.max(1, l.quantity ?? 1);
+        return wholeUnits(taxOn(money(l.total.minor / q, l.total.currency), taxRate)).minor * q;
+    };
+    /**
+     * The booking with its add-ons re-priced and its ROOMS AS BOOKED.
+     *
+     * ⚠️ AN AIRPORT TRANSFER DOES NOT RE-PRICE THE ROOM. Every line used to be
+     * re-quoted for whoever was asking: a member's non-refundable room, with the
+     * member signed out, came back at the public rate, and "HK$2,879 more" was
+     * shown for a HK$1,413 transfer - the room's own non-refundable fee rising
+     * with it (2026-09-28 audit). A rate is what the booking was made on; only
+     * moving the nights or the room changes it.
+     */
+    const withRoomsKept = (was, fresh, taxRate) => {
+        const cur = was.total.currency;
+        const rooms = was.lines.filter((l) => l.kind === 'room');
+        const extras = fresh.lines.filter((l) => l.kind === 'extra');
+        const lines = [...rooms, ...extras];
+        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;
+        void dropped;
+        return {
+            ...rest,
+            lines,
+            subtotal: money(subtotal, cur),
+            taxesAndFees: money(taxes, cur),
+            total: money(total, cur),
+            // Points are earned on what is paid, and scale with it.
+            ...(member
+                ? {
+                    member: {
+                        ...member,
+                        points: was.total.minor
+                            ? Math.round((member.points * total) / was.total.minor)
+                            : member.points,
+                    },
+                }
+                : {}),
+        };
+    };
     /**
      * A change, worked out whole: what the preview shows AND the quote the change
      * would store, from one computation.
@@ -579,6 +700,9 @@ export const createDemoHotels = (opts) => {
             change.checkOut !== undefined ||
             change.room !== undefined ||
             change.rooms !== undefined;
+        // An add-on asked for at the count it already has is no part of the change.
+        if (addOn && addOn.from === addOn.to && movesRooms)
+            addOn = undefined;
         // ⚠️ A NON-REFUNDABLE RATE CANNOT BE MOVED EITHER - ANY ROOM ON IT. The
         // hotel's own words are "cannot be cancelled or changed"; offering a change
         // would be this card contradicting the policy on the screen beside it.
@@ -589,6 +713,9 @@ 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.`);
+        // "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.');
         if (rooms.length > 1 && (change.room !== undefined || change.rooms !== undefined))
             return no(`This booking holds ${rooms.length} room types (${from.roomName}). A change of room type or of how many works on a booking of one; the dates can still move, or cancel it and book again.`);
         const raw = h.rooms.find((r) => r.id === line.roomRef);
@@ -625,7 +752,7 @@ export const createDemoHotels = (opts) => {
         // on the nights that do not overlap.
         const one = rooms.length === 1;
         const left = priceRoom(h, wantedRoom, stay, who, b.id).roomsLeft;
-        if (one && left < count)
+        if (movesRooms && one && left < count)
             return no(`${wantedRoom.name} has ${left} left for ${stay.checkIn} to ${stay.checkOut}; this change needs ${count}.`);
         const moved = linesOn(b, stay, one ? { roomId: wantedRoom.id, rooms: count } : undefined);
         // The add-on set to its new count - taken off at 0, put on when it was not.
@@ -637,12 +764,25 @@ export const createDemoHotels = (opts) => {
                     : []),
             ]
             : moved;
-        const quote = await quoteTrip({ lines }, who, b.id);
-        const lost = quote.dropped?.[0];
-        if (lost || !quote.lines.some((l) => l.kind === 'room'))
-            return no(lost
-                ? `${lost.title}: ${lost.why}`
-                : 'The rooms on this booking could not be held for the new nights.');
+        const fresh = await quoteTrip({ lines }, who, b.id);
+        let quote = fresh;
+        if (movesRooms) {
+            const lost = fresh.dropped?.[0];
+            if (lost || !fresh.lines.some((l) => l.kind === 'room'))
+                return no(lost
+                    ? `${lost.title}: ${lost.why}`
+                    : 'The rooms on this booking could not be held for the new nights.');
+        }
+        else {
+            // Only the add-on has to price; the rooms stand as booked.
+            if (addOn &&
+                addOn.to > 0 &&
+                !fresh.lines.some((l) => l.kind === 'extra' && l.extraRef === addOn?.id)) {
+                const lost = fresh.dropped?.find((d) => d.title.includes(addOn?.id ?? '')) ?? fresh.dropped?.[0];
+                return no(lost ? `${lost.title}: ${lost.why}` : `${addOn.name} cannot be added to this booking.`);
+            }
+            quote = withRoomsKept(b.quote, fresh, h.taxRate);
+        }
         const becomesLocked = wantedRoom.id !== line.roomRef && !wantedRoom.refundable;
         return {
             preview: {
@@ -685,8 +825,11 @@ export const createDemoHotels = (opts) => {
                 continue;
             const h = byId(line.hotelId);
             const taxRate = h?.taxRate ?? 0;
+            // ⚠️ THE TAX AS IT WAS CHARGED, whole units and all: a fee worked out
+            // afresh came to HK$13,200.66 on a HK$13,201 booking, and "HK$0.34 back"
+            // on a rate that returns nothing (2026-09-28 audit).
             if (!line.refundable) {
-                const withTax = Math.round(line.total.minor * (1 + taxRate));
+                const withTax = line.total.minor + roomTaxOf(line, taxRate);
                 fee += withTax;
                 rules.push(`${line.title} is a non-refundable rate: the whole stay, ${formatMoney(money(withTax, currency))}, stands.`);
                 continue;
@@ -697,9 +840,13 @@ export const createDemoHotels = (opts) => {
                 rules.push(`${line.title} is free to cancel until ${line.freeCancellationUntil.slice(0, 16).replace('T', ' ')} UTC.`);
                 continue;
             }
-            const oneNight = Math.round(line.unit.minor * (line.quantity ?? 1) * (1 + taxRate));
+            // A night at the booking's own average nightly rate - a stay of a
+            // Thursday and a Friday is not charged as its dearer night - and said
+            // as that, so nobody reads it as a particular night's price.
+            const q = Math.max(1, line.quantity ?? 1);
+            const oneNight = (line.unit.minor + wholeUnits(taxOn(line.unit, taxRate)).minor) * q;
             fee += oneNight;
-            rules.push(`${line.title}: the free window closed${line.freeCancellationUntil ? ` on ${line.freeCancellationUntil.slice(0, 10)}` : ''}, so one night plus tax, ${formatMoney(money(oneNight, currency))}, is charged.`);
+            rules.push(`${line.title}: the free window closed${line.freeCancellationUntil ? ` on ${line.freeCancellationUntil.slice(0, 10)}` : ''}, so one night at this booking's average nightly rate, plus tax, ${formatMoney(money(oneNight, currency))}, is charged.`);
         }
         if (b.quote.lines.some((l) => l.kind === 'extra')) {
             rules.push('Add-ons are dropped at no charge.');
@@ -711,6 +858,9 @@ export const createDemoHotels = (opts) => {
         today,
         bookingsForTest: () => [...bookings.values()],
         async searchHotels(q, who) {
+            // A lapsed hold stops holding here too: without it a list priced for the
+            // nights still said "No room" until some other call swept.
+            sweep();
             const terms = (q.query ?? '')
                 .toLowerCase()
                 .split(/\s+/)
@@ -747,12 +897,87 @@ export const createDemoHotels = (opts) => {
             // A room term is about a ROOM: a hotel passes when it has one, and on a
             // dated search that is the room that gets priced.
             const f = q.filters ?? {};
-            const roomOk = (r, over) => (!over.freeCancellation || r.refundable) && (!over.breakfast || !!r.breakfast);
+            const stayAsked = q.stay;
+            const wantRooms = Math.max(1, Math.min(MAX_ROOMS_PER_LINE, Math.floor(q.rooms ?? 1)));
+            // A room term is about a ROOM, and on named nights about THOSE nights:
+            // free cancellation is a window that has not closed yet, not a rate that
+            // once had one.
+            const roomOk = (h, r, over) => (!over.freeCancellation || (stayAsked ? !!freeUntilOf(h, r, stayAsked) : r.refundable)) &&
+                (!over.breakfast || !!r.breakfast);
             const passes = (h, over) => (!over.brand || h.brand.toLowerCase() === over.brand.toLowerCase()) &&
                 (over.facilities ?? []).every((k) => hasFacility(h.amenities, k)) &&
-                (!(over.freeCancellation || over.breakfast) || h.rooms.some((r) => roomOk(r, over)));
+                (!(over.freeCancellation || over.breakfast) || h.rooms.some((r) => roomOk(h, r, over)));
             const matches = placed.filter((h) => passes(h, f));
-            const count = (over) => placed.filter((h) => passes(h, over)).length;
+            // ⚠️ NAMED NIGHTS ARE PRICED, EVERY HOTEL (robin, 2026-09-28, with Trip.com
+            // and the group's own site as the reference: a place, then the dates,
+            // then hotels priced for THOSE dates). The cheapest room that takes the
+            // party, meets the room terms and has as many rooms left as were asked
+            // for, for the whole stay, taxes in - and the price order and the
+            // ceiling are about that room, not the list rate a Friday never costs.
+            //
+            // Per room terms, because a chip's count is asked with other terms than
+            // the list's own, and the cheapest room with breakfast is a different
+            // room at a different price.
+            const pricedRooms = new Map();
+            const best = new Map();
+            const bestFor = (h, over) => {
+                if (!stayAsked)
+                    return null;
+                const k = `${h.id}|${!!over.freeCancellation}|${!!over.breakfast}`;
+                const known = best.get(k);
+                if (known !== undefined)
+                    return known;
+                let found = null;
+                if (!stayProblem(stayAsked, today(h.id))) {
+                    for (const raw of h.rooms) {
+                        if (raw.sleeps < stayAsked.guests || !roomOk(h, raw, over))
+                            continue;
+                        const rk = `${h.id}|${raw.id}`;
+                        const room = pricedRooms.get(rk) ?? priceRoom(h, raw, stayAsked, who);
+                        pricedRooms.set(rk, room);
+                        if (room.roomsLeft < wantRooms)
+                            continue;
+                        if (!found || room.stayTotal.minor < found.room.stayTotal.minor)
+                            found = { room, raw };
+                    }
+                }
+                best.set(k, found);
+                return found;
+            };
+            /**
+             * The number a ceiling is held against: a night of the cheapest room
+             * that fits on named nights, the list rate otherwise - and nothing at all
+             * for a hotel with no room for those nights, which is neither under a
+             * ceiling nor over it.
+             */
+            const nightlyOf = (h, over) => {
+                if (stayAsked) {
+                    const b = bestFor(h, over);
+                    return b ? b.room.nightly.minor / minorFactor(h.currency) : undefined;
+                }
+                return h.rooms.reduce((min, r) => (r.nightly < min ? r.nightly : min), Number.POSITIVE_INFINITY);
+            };
+            // ⚠️ THE CURRENCIES OF THE MATCHES, before any ceiling is applied. This
+            // is the set a price question would have to be answered across, and it is
+            // the whole reason the price knobs live behind this seam rather than in
+            // the tool: only here is it known that "Shangri-La in Asia" spans eleven
+            // currencies and "Shangri-La in Tokyo" spans one.
+            const currencies = [...new Set(matches.map((h) => h.currency))].sort();
+            const onePrice = currencies.length === 1;
+            const ceiling = onePrice && Number(q.maxNightly) > 0 ? Number(q.maxNightly) : undefined;
+            const under = (h, over) => {
+                if (ceiling === undefined)
+                    return true;
+                const n = nightlyOf(h, over);
+                return n !== undefined && n <= ceiling;
+            };
+            // ⚠️ THE FILTERS, and what each would leave with the others applied - the
+            // count a chip shows before it is pressed (robin, 2026-09-28: 「筛选可以，
+            // 加上」). A brand is one at a time; facilities and room terms all apply.
+            // A chip counts what pressing it would LIST: under the ceiling too, and
+            // priced with its own room terms. It counted before the ceiling, and
+            // "Shangri-La 2" pressed gave one (2026-09-28 audit).
+            const count = (over) => placed.filter((h) => passes(h, over) && under(h, over)).length;
             const refine = {
                 brands: [...new Set(placed.map((h) => h.brand))]
                     .map((name) => ({ name, count: count({ ...f, brand: name }) }))
@@ -802,72 +1027,59 @@ export const createDemoHotels = (opts) => {
                     return size(b) - size(a) || a.cityId.localeCompare(b.cityId);
                 })
                 : matches;
-            // ⚠️ THE CURRENCIES OF THE MATCHES, before any ceiling is applied. This
-            // is the set a price question would have to be answered across, and it is
-            // the whole reason the price knobs live behind this seam rather than in
-            // the tool: only here is it known that "Shangri-La in Asia" spans eleven
-            // currencies and "Shangri-La in Tokyo" spans one.
-            const currencies = [...new Set(matches.map((h) => h.currency))].sort();
-            const onePrice = currencies.length === 1;
-            // ⚠️ NAMED NIGHTS ARE PRICED, EVERY HOTEL (robin, 2026-09-28, with Trip.com
-            // and the group's own site as the reference: a place, then the dates,
-            // then hotels priced for THOSE dates). The cheapest room that takes the
-            // party and has as many rooms left as were asked for, for the whole
-            // stay, taxes in - and the price order and the ceiling are about that
-            // number, not the list rate a Friday never costs.
-            const wantRooms = Math.max(1, Math.min(MAX_ROOMS_PER_LINE, Math.floor(q.rooms ?? 1)));
             const forStay = new Map();
             const noRooms = new Map();
-            if (q.stay) {
-                const stayAsked = q.stay;
+            if (stayAsked) {
                 for (const h of matches) {
                     const problem = stayProblem(stayAsked, today(h.id));
-                    if (problem) {
-                        noRooms.set(h.id, problem);
-                        continue;
-                    }
-                    let best;
-                    for (const raw of h.rooms) {
-                        if (raw.sleeps < stayAsked.guests)
-                            continue;
-                        if (!roomOk(raw, f))
-                            continue;
-                        const room = priceRoom(h, raw, stayAsked, who);
-                        if (room.roomsLeft < wantRooms)
-                            continue;
-                        if (!best || room.stayTotal.minor < best.room.stayTotal.minor)
-                            best = { room, raw };
-                    }
-                    if (!best) {
-                        noRooms.set(h.id, 'No room here can be booked for those nights.');
+                    const b = problem ? null : bestFor(h, f);
+                    if (!b) {
+                        noRooms.set(h.id, problem ?? 'No room here can be booked for those nights.');
                         continue;
                     }
                     forStay.set(h.id, {
-                        total: multiplyMoney(best.room.stayTotal, wantRooms),
-                        nightly: best.room.nightly,
-                        room: best.raw.name,
+                        total: multiplyMoney(b.room.stayTotal, wantRooms),
+                        nightly: b.room.nightly,
+                        room: b.raw.name,
                         rooms: wantRooms,
-                        nights: best.room.nights,
-                        roomsLeft: best.room.roomsLeft,
-                        freeCancellation: !!best.room.freeCancellationUntil,
+                        nights: b.room.nights,
+                        roomsLeft: b.room.roomsLeft,
+                        freeCancellation: !!b.room.freeCancellationUntil,
                     });
                 }
             }
-            const cheapest = (h) => {
-                if (q.stay) {
-                    const f = forStay.get(h.id);
-                    return f ? f.nightly.minor / minorFactor(h.currency) : Number.POSITIVE_INFINITY;
-                }
-                return h.rooms.reduce((min, r) => (r.nightly < min ? r.nightly : min), Number.POSITIVE_INFINITY);
-            };
-            const ceiling = onePrice && Number(q.maxNightly) > 0 ? Number(q.maxNightly) : undefined;
-            const passed = ceiling === undefined ? ranked : ranked.filter((h) => cheapest(h) <= ceiling);
-            const over = ceiling === undefined ? [] : ranked.filter((h) => cheapest(h) > ceiling);
+            /**
+             * What the price order reads: the stay's total, taxes in, when nights are
+             * named - the number on the tile. It read the pre-tax average night, and
+             * Pudong's ¥3,364 sorted above Kerry Pudong's ¥3,138: two taxes, one
+             * currency (2026-09-28 audit). A hotel with no room has no price, and
+             * goes last whichever way the list is sorted.
+             */
+            const priceKey = (h) => stayAsked ? forStay.get(h.id)?.total.minor : nightlyOf(h, f);
+            const passed = ranked.filter((h) => under(h, f));
+            // Over the ceiling means PRICED and over it. A hotel with no room for the
+            // nights was counted here too - "2 more came in over the ceiling" about
+            // two that were full.
+            const over = ceiling === undefined
+                ? []
+                : ranked.filter((h) => {
+                    const n = nightlyOf(h, f);
+                    return n !== undefined && n > ceiling;
+                });
             // A price order across currencies is an exchange rate we picked. Dropped,
             // not approximated; `currencies` tells the caller to say so.
             const sort = q.sort ?? 'group';
+            const byPrice = (a, b, dir) => {
+                const x = priceKey(a);
+                const y = priceKey(b);
+                if (x === undefined)
+                    return y === undefined ? 0 : 1;
+                if (y === undefined)
+                    return -1;
+                return (x - y) * dir;
+            };
             const ordered = (sort === 'price-low' || sort === 'price-high') && onePrice
-                ? [...passed].sort((a, b) => sort === 'price-low' ? cheapest(a) - cheapest(b) : cheapest(b) - cheapest(a))
+                ? [...passed].sort((a, b) => byPrice(a, b, sort === 'price-low' ? 1 : -1))
                 : sort === 'rating'
                     ? // A hotel that publishes no rating is not a hotel with a bad one.
                         // They keep their order and follow the ones that do.
@@ -896,6 +1108,7 @@ export const createDemoHotels = (opts) => {
                 currencies,
                 refine,
                 ...(q.filters ? { beforeFilters: placed.length } : {}),
+                ...(ceiling !== undefined ? { beforeCeiling: matches.length } : {}),
                 facets: {
                     countries: tally((h) => h.country ?? h.city),
                     cities: tally((h) => h.city).map((c) => ({
@@ -908,10 +1121,11 @@ export const createDemoHotels = (opts) => {
                 // and never mixed in with the passes.
                 ...(passed.length === 0 && over.length
                     ? {
+                        // Priced like the list: on named nights, what those nights cost.
                         nearest: [...over]
-                            .sort((a, b) => cheapest(a) - cheapest(b))
+                            .sort((a, b) => byPrice(a, b, 1))
                             .slice(0, 3)
-                            .map(toHotel),
+                            .map(priced),
                     }
                     : {}),
             };
@@ -1051,6 +1265,10 @@ export const createDemoHotels = (opts) => {
             if (problems.length) {
                 throw demoError('partly-unavailable', `Nothing was booked. ${problems.join(' ')} The trip is as it was - take that out or change it, then ask again.`);
             }
+            const live = [...bookings.values()].filter((b) => b.owners.has(who.sessionId) && b.status === 'requested').length;
+            if (live + groups.length > MAX_HOLDS_PER_CONVERSATION) {
+                throw demoError('too-many-holds', `Nothing was booked. This conversation already holds ${live} booking${live === 1 ? '' : 's'}, and ${MAX_HOLDS_PER_CONVERSATION} at once is the most - cancel one that is not needed, then ask again.`);
+            }
             const quotes = await Promise.all(groups.map((g) => quoteTrip({ lines: g }, who)));
             const t = now();
             const made = [];
@@ -1064,9 +1282,8 @@ export const createDemoHotels = (opts) => {
                 }
                 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();
-                seq += 1;
                 made.push({
-                    id: `bk_${Date.now().toString(36)}_${seq}`,
+                    id: `bk_${randomUUID()}`,
                     confirmationCode: confirmationCode(new Set(made.map((m) => m.confirmationCode))),
                     status: 'requested',
                     createdAt: new Date(t).toISOString(),
@@ -1076,26 +1293,29 @@ export const createDemoHotels = (opts) => {
                     stay: quote.stay,
                     guest,
                     quote,
-                    sessionId: who.sessionId,
+                    owners: new Set([who.sessionId]),
                     ...(cleanRequests(requests) ? { requests: cleanRequests(requests) } : {}),
                 });
             }
+            makeRoom(made.length);
             for (const booking of made)
                 bookings.set(booking.id, booking);
-            return made.map((booking) => ({ ...booking }));
+            return made.map(publicBooking);
         },
         async listBookings(who, limit = 10) {
             sweep();
+            // A negative limit reached `slice(0, -2)` and returned all but two.
+            const most = Math.max(1, Math.min(MAX_PAGE, Math.floor(Number(limit) > 0 ? limit : 10)));
             return [...bookings.values()]
-                .filter((b) => b.sessionId === who.sessionId)
+                .filter((b) => b.owners.has(who.sessionId))
                 .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
-                .slice(0, limit)
-                .map((b) => ({ ...b }));
+                .slice(0, most)
+                .map(publicBooking);
         },
         async findBooking(ref, who) {
             sweep();
             const b = findBooking(ref, who);
-            return b ? { ...b } : null;
+            return b ? publicBooking(b) : null;
         },
         /**
          * What changing the nights or the room count would do.
@@ -1129,7 +1349,7 @@ export const createDemoHotels = (opts) => {
                 changedAt: new Date(now()).toISOString(),
             };
             bookings.set(b.id, updated);
-            return { ...updated };
+            return publicBooking(updated);
         },
         async previewCancellation(bookingRef, who) {
             sweep();
@@ -1158,13 +1378,11 @@ export const createDemoHotels = (opts) => {
         },
         async cancelBooking(bookingRef, who, reason) {
             sweep();
-            const wanted = bookingRef.trim().toLowerCase();
-            const b = [...bookings.values()].find((x) => (x.id.toLowerCase() === wanted || x.confirmationCode.toLowerCase() === wanted) &&
-                mine(x, who));
+            const b = findBooking(bookingRef, who);
             if (!b)
                 return null;
             if (b.status !== 'requested' && b.status !== 'confirmed')
-                return { ...b };
+                return publicBooking(b);
             const { fee } = feeFor(b, now());
             b.status = 'cancelled';
             b.cancelledAt = new Date(now()).toISOString();
@@ -1174,7 +1392,7 @@ export const createDemoHotels = (opts) => {
                     ...b.guest,
                     notes: [b.guest.notes, `Cancelled: ${reason}`].filter(Boolean).join(' | '),
                 };
-            return { ...b };
+            return publicBooking(b);
         },
         async policies(hotelId) {
             const h = byId(hotelId);