@curless/hotel-storefront 0.23.1 → 0.24.0

package/dist/huazhu/backend.js

@@ -0,0 +1,1318 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { DEFAULT_PAGE, MAX_PAGE, REQUEST_KINDS, REQUEST_NOTE_MAX, } from '../backend.js';
+import { addDays, nights as nightsBetween, stayProblem, todayAt } from '../dates.js';
+import { MAX_HOLDS_PER_CONVERSATION, byWords, splitByStay } from '../demo-hotels.js';
+import { FACILITIES, hasFacility } from '../facilities.js';
+import { formatMoney, minorFactor, money, multiplyMoney, toMinor } from '../money.js';
+import { MAX_ROOMS_PER_LINE } from '../trip.js';
+import { statusOf } from './bookings.js';
+import { describePolicy, feeFor, freeUntilOf, nightAuditOf, parseCancelPolicy, penaltyAt, refundableFrom, } from './cancel-policy.js';
+import { haystackOf, inPlace, roomPhoto, toHotel } from './catalog.js';
+import { HuazhuRefusal, HuazhuUnreachable } from './client.js';
+import { ariRanges, bookableNow, clockAt, offeredAtAll, sell, } from './sellable.js';
+export const HUAZHU_CAPABILITIES = {
+    members: false,
+    extras: false,
+    changes: false,
+    booking: 'pay-at-hotel',
+};
+/**
+ * The most hotels priced for one search. A city can hold hundreds of Huazhu
+ * hotels, and every one priced is two calls to Huazhu; past this, the page is
+ * priced and a price ORDER or CEILING is not applied - and the answer says so,
+ * rather than sorting the twenty it happened to price.
+ */
+export const PRICE_ALL = 20;
+const PRICE_CONCURRENCY = 4;
+/** What a room is called here: the room type, then the rate when there is more than one. */
+const ROOM_SEP = '~';
+const roomIdOf = (p) => `${p.roomTypeCode}${ROOM_SEP}${p.rateCode}`;
+/** 客人备注 for the preferences the desk understands, in the hotel's language. */
+const REQUEST_ZH = {
+    'king-bed': '大床',
+    'twin-beds': '双床',
+    'high-floor': '高楼层',
+    'low-floor': '低楼层',
+    'quiet-room': '安静房间',
+    'connecting-rooms': '连通房',
+    'early-check-in': '提前入住',
+    'late-arrival': '晚到',
+    'accessible-room': '无障碍房',
+};
+const WINDOW = {
+    '1': 'Window',
+    '2': 'Some rooms without a window',
+    '3': 'No window',
+    '4': 'Window onto an inner courtyard',
+};
+const pool = async (items, n, fn) => {
+    const out = new Array(items.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(n, items.length) }, async () => {
+        for (let i = next++; i < items.length; i = next++)
+            out[i] = await fn(items[i]);
+    }));
+    return out;
+};
+/** 16 characters a name part, `|` and `'` never - Huazhu's limits on the contact. */
+const contactOf = (g) => {
+    const name = g.name.replace(/\s+/g, ' ').trim();
+    const cut = name.lastIndexOf(' ');
+    const last = cut > 0 ? name.slice(cut + 1) : name;
+    const first = cut > 0 ? name.slice(0, cut) : '';
+    if (last.length > 16 || first.length > 16)
+        return "Huazhu's booking system takes a name of up to 16 characters for the family name and 16 for the given names. Ask the guest how the name should be written within that.";
+    const email = g.email.trim();
+    const phone = (g.phone ?? '').replace(/[\s()-]/g, '');
+    return {
+        lastName: last,
+        ...(first ? { firstName: first } : {}),
+        // The contact's email is capped at 32 characters. A longer one is kept
+        // here - it is how the booking is found - and not sent, rather than cut.
+        ...(email.length <= 32 ? { email } : {}),
+        ...(phone && phone.length <= 32 ? { phone } : {}),
+    };
+};
+const commentOf = (r, note) => {
+    const kinds = (r?.kinds ?? []).filter((k) => REQUEST_KINDS.includes(k));
+    const words = [
+        ...kinds.map((k) => REQUEST_ZH[k]),
+        ...(r?.arrivingAt ? [`预计${r.arrivingAt}到店`] : []),
+    ];
+    const free = (r?.note ?? note ?? '').replace(/\s+/g, ' ').trim().slice(0, REQUEST_NOTE_MAX);
+    const text = [words.join('，'), free].filter(Boolean).join('。').replace(/[|']/g, ' ');
+    return text ? text.slice(0, 512) : undefined;
+};
+const cleanRequests = (r) => {
+    if (!r)
+        return undefined;
+    const kinds = [...new Set(r.kinds ?? [])].filter((k) => REQUEST_KINDS.includes(k));
+    const arrivingAt = /^([01]\d|2[0-3]):[0-5]\d$/.test(r.arrivingAt ?? '')
+        ? r.arrivingAt
+        : undefined;
+    const note = (r.note ?? '').replace(/\s+/g, ' ').trim().slice(0, REQUEST_NOTE_MAX);
+    if (kinds.length === 0 && !arrivingAt && !note)
+        return undefined;
+    return { kinds, ...(arrivingAt ? { arrivingAt } : {}), ...(note ? { note } : {}) };
+};
+/** A refusal from prebook or book, in words a guest can act on. */
+const refusalWords = (err, room, currency) => {
+    const detail = err.detail ? ` (${err.detail})` : '';
+    switch (err.code) {
+        case 5108:
+        case 5209: {
+            const ari = err.content?.reservationsAri?.[0];
+            const now = ari?.rates?.[0]?.amountAfterTax?.reduce((a, b) => a + (Number(b) || 0), 0);
+            return `The price of ${room} changed since it was shown${now ? `: it is now ${formatMoney(money(toMinor(now, currency), currency))} a room for the stay` : ''}. Open the hotel again for today's price.`;
+        }
+        case 5109:
+        case 5210:
+            return `${room} has no rooms left for those nights.`;
+        case 5110:
+        case 5214:
+            return `${room} cannot be booked for that many rooms at once.`;
+        case 5111:
+        case 5215:
+            return `${room} does not take that many guests in a room.`;
+        case 5120:
+        case 5233:
+            return `${room} cannot be booked for those nights${detail}.`;
+        case 5114:
+        case 5211:
+        case 5116:
+        case 5213:
+            return `${room} cannot be booked to be paid at the hotel.`;
+        case 5107:
+        case 5207:
+        case 5128:
+        case 5238:
+            return `${room} is not on sale that far ahead.`;
+        default:
+            return `Huazhu did not accept ${room}: ${err.huazhuMessage}${detail}.`;
+    }
+};
+export const createHuazhuHotels = (opts) => {
+    const { client, catalog, store, reconciler } = opts;
+    const now = opts.now ?? (() => Date.now());
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const ariTtl = opts.ariTtlMs ?? 60_000;
+    const productsTtl = opts.productsTtlMs ?? 10 * 60_000;
+    const allowTags = new Set(opts.allowTags ?? []);
+    const view = { language: opts.language, tz: opts.tz };
+    const today = () => todayAt(now(), opts.tz);
+    // ------------------------------------------------------------- lookups ----
+    const hotelsNow = () => catalog.all().map((h) => ({ raw: h, hotel: toHotel(h, view, now()) }));
+    /** A hotel by id, by its name as written, or unambiguously by part of it. */
+    const findHotel = (ref) => {
+        const wanted = ref.trim();
+        if (!wanted)
+            return undefined;
+        const byId = catalog.get(wanted);
+        if (byId)
+            return byId;
+        const all = catalog.all();
+        const low = wanted.toLowerCase();
+        const exact = all.find((h) => h.hotelName.toLowerCase() === low || (h.hotelNameEn ?? '').toLowerCase() === low);
+        if (exact)
+            return exact;
+        if (wanted.length >= 4) {
+            const part = all.filter((h) => h.hotelName.toLowerCase().includes(low) ||
+                (h.hotelNameEn ?? '').toLowerCase().includes(low));
+            if (part.length === 1)
+                return part[0];
+        }
+        const en = all.filter((h) => h.hotelNameEn).map((h) => ({ name: h.hotelNameEn, h }));
+        return byWords(en, wanted)?.h;
+    };
+    const productsCache = new Map();
+    const productsOf = async (hotelId) => {
+        const hit = productsCache.get(hotelId);
+        if (hit && now() - hit.at < productsTtl)
+            return hit.value;
+        const value = await client
+            .products(hotelId)
+            .then((c) => (c.products ?? []).filter((p) => offeredAtAll(p, allowTags)))
+            .catch((err) => {
+            if (err instanceof HuazhuRefusal && [4101, 4102, 4103, 2007].includes(err.code))
+                return [];
+            throw err;
+        });
+        productsCache.set(hotelId, { at: now(), value });
+        return value;
+    };
+    const ariCache = new Map();
+    /** Every product's prices, rules and rooms left, one element per date from `start` to `end`. */
+    const ariFor = async (hotelId, start, end, fresh = false) => {
+        const key = `${hotelId}|${start}|${end}`;
+        const hit = ariCache.get(key);
+        if (!fresh && hit && now() - hit.at < ariTtl)
+            return hit.value;
+        const ranges = ariRanges(start, end);
+        const parts = await Promise.all(ranges.map(async (r) => {
+            const [offers, inventory] = await Promise.all([
+                client.offers(hotelId, r.start, r.end).catch((err) => {
+                    if (err instanceof HuazhuRefusal && [4206, 2008].includes(err.code))
+                        return { dailyOffers: [] };
+                    throw err;
+                }),
+                client.inventory(hotelId, r.start, r.end).catch((err) => {
+                    if (err instanceof HuazhuRefusal && [4306, 2008].includes(err.code))
+                        return {
+                            dailyInventories: [],
+                        };
+                    throw err;
+                }),
+            ]);
+            return {
+                range: r,
+                offers: offers.dailyOffers ?? [],
+                inventory: inventory.dailyInventories ?? [],
+            };
+        }));
+        const out = new Map();
+        const keys = new Set(parts.flatMap((p) => p.offers.map((o) => roomIdOf(o))));
+        for (const k of keys) {
+            const merged = mergeOffers(parts.map((p) => ({
+                days: nightsBetween(p.range.start, p.range.end) + 1,
+                offer: p.offers.find((o) => roomIdOf(o) === k),
+            })));
+            if (!merged)
+                continue;
+            const inv = parts.flatMap((p) => {
+                const days = nightsBetween(p.range.start, p.range.end) + 1;
+                const row = p.inventory.find((i) => roomIdOf(i) === k)?.inventories ?? [];
+                return Array.from({ length: days }, (_, i) => row[i] ?? null);
+            });
+            out.set(k, { start, offer: merged, inventory: inv });
+        }
+        ariCache.set(key, { at: now(), value: out });
+        if (ariCache.size > 500)
+            ariCache.delete(ariCache.keys().next().value);
+        return out;
+    };
+    /** Every sellable-or-not product of one hotel for one stay. */
+    const priceStay = async (h, stay, rooms, fresh = false) => {
+        const products = await productsOf(h.hotelId);
+        if (products.length === 0)
+            return [];
+        const ari = await ariFor(h.hotelId, stay.checkIn, stay.checkOut, fresh);
+        const context = {
+            checkIn: stay.checkIn,
+            checkOut: stay.checkOut,
+            adults: stay.guests,
+            rooms,
+            today: today(),
+            clock: clockAt(now(), opts.tz),
+            paymentType: opts.paymentType,
+            allowTags,
+        };
+        return products
+            .filter((p) => bookableNow(p.bookWindow, stay.checkIn, context.clock))
+            .map((product) => {
+            const roomType = (h.hotelRoomTypeList ?? []).find((r) => r.roomTypeCode === product.roomTypeCode);
+            const w = ari.get(roomIdOf(product));
+            const res = w
+                ? sell(product, w, roomType, context)
+                : { ok: false, kind: 'no-price', why: 'no price for those nights' };
+            return { product, roomType, res };
+        })
+            .filter((x) => !(x.roomType && x.roomType.status === 0));
+    };
+    const policyOf = (code) => parseCancelPolicy(code);
+    const toRoom = (h, p, stay) => {
+        const s = p.res;
+        const cur = s.currency;
+        const n = s.after.length;
+        const after = s.after.map((x) => toMinor(x, cur));
+        const total = after.reduce((a, b) => a + b, 0);
+        const pre = s.before ? s.before.map((x) => toMinor(x, cur)).reduce((a, b) => a + b, 0) : total;
+        const policy = policyOf(s.cancelCode);
+        const freeUntil = policy ? freeUntilOf(policy, stay.checkIn, opts.tz, now()) : undefined;
+        const rt = p.roomType;
+        const beds = (rt?.bedTypeList ?? [])
+            .map((b) => [b.bedTypeName, b.bedSpec].filter(Boolean).join(' '))
+            .filter(Boolean);
+        return {
+            id: roomIdOf(p.product),
+            name: [p.product.roomTypeName, p.product.rateCodeName].filter(Boolean).join(' · '),
+            sleeps: s.sleeps,
+            ...(rt?.hotelArea ? { sizeSqm: rt.hotelArea } : {}),
+            ...(beds.length ? { beds: beds.join(' / ') } : {}),
+            ...(rt?.isHasWindow && WINDOW[rt.isHasWindow] ? { view: WINDOW[rt.isHasWindow] } : {}),
+            breakfast: !!s.meal,
+            ...(roomPhoto(h, p.product.roomTypeCode)
+                ? { imageUrl: roomPhoto(h, p.product.roomTypeCode) }
+                : {}),
+            nightly: money(Math.round(pre / n), cur),
+            stayTotal: money(total, cur),
+            taxesAndFees: money(total - pre, cur),
+            nights: n,
+            refundable: policy ? refundableFrom(policy, stay.checkIn, opts.tz, now()) : false,
+            ...(freeUntil ? { freeCancellationUntil: new Date(freeUntil).toISOString() } : {}),
+            roomsLeft: s.roomsLeft,
+        };
+    };
+    /** Why nothing here can be sold for these nights - the most useful reason first. */
+    const noRoomsWhy = (priced, stay, rooms) => {
+        if (priced.length === 0)
+            return 'This hotel has no rooms on sale through this connector.';
+        const fails = priced.map((p) => p.res).filter((r) => !r.ok);
+        const kinds = new Set(fails.map((f) => f.kind));
+        const only = (k) => kinds.size === 1 && kinds.has(k);
+        if (only('party')) {
+            const largest = Math.max(...fails.map((f) => Number(/\d+/.exec(f.why)?.[0] ?? 0)));
+            return `No room here sleeps ${stay.guests}; the largest sleeps ${largest}, so two rooms would work.`;
+        }
+        if (only('prepaid'))
+            return 'Every rate here for those nights is paid in advance, and this connector books rates paid at the hotel.';
+        if (only('sold-out'))
+            return rooms > 1
+                ? `No room type here has ${rooms} left for those nights.`
+                : 'Every room type here is taken for those nights.';
+        if (only('too-many-rooms'))
+            return `No rate here books ${rooms} rooms at once; ask for fewer.`;
+        const rule = fails.find((f) => f.kind === 'stay-rule');
+        if (rule)
+            return `Not for those nights: ${rule.why}.`;
+        if (kinds.has('closed'))
+            return 'Not on sale for those nights.';
+        return 'No room here can be booked for those nights.';
+    };
+    // --------------------------------------------------------------- quote ----
+    const quoteLines = async (trip, fresh = false) => {
+        const lines = [];
+        const dropped = [];
+        const sold = new Map();
+        let currency;
+        let subtotal = 0;
+        let taxes = 0;
+        const taken = new Map();
+        for (const [i, line] of trip.lines.entries()) {
+            const h = catalog.get(line.hotelId);
+            if (!h) {
+                dropped.push({ title: line.hotelId, why: 'That hotel is not in this connector any more.' });
+                continue;
+            }
+            const hotelName = toHotel(h, view, now()).name;
+            if (line.kind !== 'room') {
+                dropped.push({
+                    title: hotelName,
+                    why: 'Huazhu hotels sell rooms only here; there are no add-ons.',
+                });
+                continue;
+            }
+            const problem = stayProblem(line.stay, today());
+            if (problem) {
+                dropped.push({ title: hotelName, why: problem });
+                continue;
+            }
+            const wanted = Math.max(1, Math.floor(line.rooms ?? 1));
+            let priced;
+            try {
+                priced = await priceStay(h, line.stay, wanted, fresh);
+            }
+            catch (err) {
+                dropped.push({
+                    title: hotelName,
+                    why: `Huazhu could not be asked for today's price just now (${err.message}).`,
+                });
+                continue;
+            }
+            const p = priced.find((x) => roomIdOf(x.product) === line.roomId);
+            if (!p) {
+                dropped.push({
+                    title: `${hotelName} - ${line.roomId}`,
+                    why: 'That rate is no longer sold.',
+                });
+                continue;
+            }
+            if (!p.res.ok) {
+                dropped.push({ title: `${hotelName} - ${p.product.roomTypeName}`, why: `${p.res.why}.` });
+                continue;
+            }
+            const held = `${h.hotelId}|${line.roomId}|${line.stay.checkIn}|${line.stay.checkOut}`;
+            const already = taken.get(held) ?? 0;
+            if (p.res.roomsLeft - already < wanted) {
+                dropped.push({
+                    title: `${hotelName} - ${p.product.roomTypeName}`,
+                    why: `Only ${Math.max(0, p.res.roomsLeft - already)} left.`,
+                });
+                continue;
+            }
+            taken.set(held, already + wanted);
+            const room = toRoom(h, p, line.stay);
+            if (currency === undefined)
+                currency = room.stayTotal.currency;
+            if (room.stayTotal.currency !== currency) {
+                dropped.push({
+                    title: hotelName,
+                    why: `This trip is priced in ${currency} and ${hotelName} charges in ${room.stayTotal.currency}. No exchange rate is invented here - book those nights as their own trip.`,
+                });
+                continue;
+            }
+            const preTax = (room.stayTotal.minor - room.taxesAndFees.minor) * wanted;
+            subtotal += preTax;
+            taxes += room.taxesAndFees.minor * wanted;
+            sold.set(i, p);
+            lines.push({
+                kind: 'room',
+                hotelId: h.hotelId,
+                hotelName,
+                roomRef: room.id,
+                title: room.name,
+                detail: [
+                    room.beds,
+                    room.view,
+                    p.res.meal
+                        ? `${p.res.meal}${p.res.mealCount > 1 ? ` × ${p.res.mealCount}` : ''}`
+                        : 'Room only',
+                ]
+                    .filter(Boolean)
+                    .join(' · '),
+                stay: line.stay,
+                nights: room.nights,
+                quantity: wanted,
+                unit: room.nightly,
+                total: money(preTax, room.stayTotal.currency),
+                refundable: room.refundable,
+                freeCancellationUntil: room.freeCancellationUntil,
+                day: line.stay.checkIn,
+            });
+        }
+        const cur = currency ?? 'CNY';
+        const stays = lines.flatMap((l) => (l.stay ? [l.stay] : []));
+        const first = stays.map((s) => s.checkIn).sort()[0];
+        const last = stays
+            .map((s) => s.checkOut)
+            .sort()
+            .at(-1);
+        return {
+            lines,
+            subtotal: money(subtotal, cur),
+            taxesAndFees: money(taxes, cur),
+            total: money(subtotal + taxes, cur),
+            ...(first && last
+                ? {
+                    stay: {
+                        checkIn: first,
+                        checkOut: last,
+                        guests: Math.max(...stays.map((s) => s.guests)),
+                    },
+                }
+                : {}),
+            ...(dropped.length ? { dropped } : {}),
+            sold,
+        };
+    };
+    const quote = async (trip) => {
+        const { sold, ...q } = await quoteLines(trip);
+        void sold;
+        return q;
+    };
+    // ------------------------------------------------------------ bookings ----
+    const publicBooking = (b) => ({
+        id: b.id,
+        confirmationCode: b.confirmationCode,
+        status: b.status,
+        createdAt: b.createdAt,
+        hotelId: b.hotelId,
+        hotelName: b.hotelName,
+        stay: b.stay,
+        guest: b.guest,
+        quote: b.quote,
+        ...(b.cancelledAt ? { cancelledAt: b.cancelledAt } : {}),
+        ...(b.cancellationFee ? { cancellationFee: b.cancellationFee } : {}),
+        ...(b.requests ? { requests: b.requests } : {}),
+    });
+    const findOwn = (ref, who) => {
+        const wanted = ref.trim().toLowerCase();
+        if (!wanted)
+            return undefined;
+        const matches = (b) => [b.id, b.confirmationCode, b.resId, b.distributorResId]
+            .filter(Boolean)
+            .some((x) => String(x).toLowerCase() === wanted);
+        const own = store.all().find((b) => b.owners.includes(who.sessionId) && matches(b));
+        if (own || !who.email)
+            return own;
+        // ⚠️ A CODE AND ITS EMAIL, never an id and never an email alone - see the seam.
+        const email = who.email.trim().toLowerCase();
+        const there = store
+            .all()
+            .find((b) => [b.confirmationCode, b.resId]
+            .filter(Boolean)
+            .some((x) => String(x).toLowerCase() === wanted) &&
+            b.guest.email.trim().toLowerCase() === email);
+        if (there) {
+            const owners = [...new Set([...there.owners, who.sessionId])];
+            // The conversation that made it stays; the oldest finder goes.
+            while (owners.length > 10)
+                owners.splice(1, 1);
+            store.update(there.id, { owners });
+        }
+        return there;
+    };
+    /** Huazhu's own word on a booking, at most once a minute each. */
+    const refresh = async (b) => {
+        if (!b.resId || b.pendingSince !== undefined)
+            return b;
+        if (b.refreshedAt && now() - b.refreshedAt < 60_000)
+            return b;
+        try {
+            const d = await client.detail(b.resId);
+            const status = statusOf(d.status);
+            const line = d.reservations?.[0];
+            return (store.update(b.id, {
+                hotelStatus: d.status,
+                status,
+                refreshedAt: now(),
+                ...(line?.cancelPolicyCode ? { cancelCode: line.cancelPolicyCode } : {}),
+                ...(status === 'cancelled' && !b.cancelledAt
+                    ? { cancelledAt: new Date(now()).toISOString() }
+                    : {}),
+            }) ?? b);
+        }
+        catch {
+            // Unreachable or refused: what we last knew stands, and says so by its age.
+            return b;
+        }
+    };
+    const feeNow = (b) => {
+        const policy = policyOf(b.cancelCode);
+        const amounts = {
+            currency: b.quote.total.currency,
+            nightlyMinor: b.nightlyMinor,
+            rooms: b.rooms,
+        };
+        const total = b.nightlyMinor.reduce((a, c) => a + c, 0) * b.rooms;
+        if (!policy) {
+            return {
+                fee: total,
+                forbidden: false,
+                rule: `This rate's terms (${b.cancelCode || 'none given'}) could not be read here, so the fee shown is the most it could be. Huazhu works out the actual fee when it cancels.`,
+                freeUntil: undefined,
+            };
+        }
+        const penalty = penaltyAt(policy, b.stay.checkIn, b.tz, now());
+        const fee = feeFor(penalty, amounts);
+        return {
+            fee: fee ?? total,
+            forbidden: fee === null,
+            rule: describePolicy(policy, b.stay.checkIn, b.tz, amounts),
+            freeUntil: freeUntilOf(policy, b.stay.checkIn, b.tz, now()),
+        };
+    };
+    /** Chase one unanswered booking call for a little while, inside the guest's request. */
+    const settle = async (row) => {
+        const until = now() + (opts.settleWithinMs ?? 25_000);
+        let current = row;
+        while (current.pendingSince !== undefined && now() < until) {
+            await sleep(5_000);
+            await reconciler.check(current);
+            current = store.get(row.id) ?? current;
+        }
+        return current;
+    };
+    const distributorResId = () => `CUR${now().toString(36).toUpperCase()}${randomBytes(6).toString('hex').toUpperCase()}`;
+    return {
+        brand: opts.brand,
+        capabilities: HUAZHU_CAPABILITIES,
+        imageDomains() {
+            const hosts = new Set();
+            for (const h of catalog.all()) {
+                for (const p of h.hotelPhotoList ?? []) {
+                    try {
+                        const u = p.fileUrl &&
+                            new URL(p.fileUrl.replace(/^http:\/\//, 'https://').replace(/^\/\//, 'https://'));
+                        if (u)
+                            hosts.add(u.origin);
+                    }
+                    catch {
+                        // not a URL
+                    }
+                }
+            }
+            return [...hosts];
+        },
+        health() {
+            const rows = store.all();
+            return {
+                catalog: catalog.state(),
+                bookings: rows.length,
+                pending: rows.filter((r) => r.pendingSince !== undefined).length,
+                needsAPerson: rows.filter((r) => r.attention).length,
+            };
+        },
+        async searchHotels(q) {
+            const terms = (q.query ?? '')
+                .toLowerCase()
+                .split(/\s+/)
+                .filter((t) => t.length > 0 && !(t.length === 1 && /[a-z0-9]/.test(t)));
+            const place = q.city?.trim();
+            const all = hotelsNow();
+            const placed = all.filter(({ raw }) => {
+                if (place && !inPlace(raw, place))
+                    return false;
+                if (terms.length === 0)
+                    return true;
+                const hay = haystackOf(raw);
+                return terms.every((t) => hay.includes(t));
+            });
+            const f = q.filters ?? {};
+            const stay = q.stay;
+            const wantRooms = Math.max(1, Math.min(MAX_ROOMS_PER_LINE, Math.floor(q.rooms ?? 1)));
+            const unapplied = [];
+            const ignored = {};
+            const roomTerms = !!(f.freeCancellation || f.breakfast);
+            const passesStatic = (h, over) => (!over.brand || h.brand.toLowerCase() === over.brand.toLowerCase()) &&
+                (over.facilities ?? []).every((k) => hasFacility(h.amenities, k));
+            let matches = placed.filter(({ hotel }) => passesStatic(hotel, f));
+            // ⚠️ PRICED WHEN THE NIGHTS ARE NAMED - but a city can hold hundreds of
+            // these hotels and each one is two calls to Huazhu. Everything is priced
+            // when there are few enough; past that, only the page, and the price
+            // order, the ceiling and the room terms are not applied to a list they
+            // could not see all of. Said, not approximated.
+            const priceEverything = !!stay && matches.length <= PRICE_ALL;
+            const wantsPriceKnob = q.sort === 'price-low' || q.sort === 'price-high' || Number(q.maxNightly) > 0;
+            if (!priceEverything && (wantsPriceKnob || roomTerms)) {
+                if (q.sort === 'price-low' || q.sort === 'price-high')
+                    ignored.sort = true;
+                if (Number(q.maxNightly) > 0)
+                    ignored.ceiling = true;
+                if (roomTerms)
+                    ignored.roomTerms = true;
+            }
+            if (stay && !priceEverything && (wantsPriceKnob || roomTerms)) {
+                unapplied.push(`${matches.length} hotels matched - too many to price at once, so ${[
+                    wantsPriceKnob ? 'the price order and ceiling' : '',
+                    roomTerms ? 'the free-cancellation and breakfast filters' : '',
+                ]
+                    .filter(Boolean)
+                    .join(' and ')} were not applied. A district, a brand or a landmark narrows it.`);
+            }
+            if (!stay && (wantsPriceKnob || roomTerms)) {
+                unapplied.push('Prices, free cancellation and breakfast belong to a room on given nights, and Huazhu publishes no price without them - with check-in and check-out they apply.');
+            }
+            const best = new Map();
+            const why = new Map();
+            const bestKey = (id, over) => `${id}|${!!over.freeCancellation}|${!!over.breakfast}`;
+            const pricedRooms = new Map();
+            const priceHotel = async (raw) => {
+                if (!stay || pricedRooms.has(raw.hotelId))
+                    return;
+                const problem = stayProblem(stay, today());
+                if (problem) {
+                    pricedRooms.set(raw.hotelId, []);
+                    why.set(raw.hotelId, problem);
+                    return;
+                }
+                try {
+                    const priced = await priceStay(raw, stay, wantRooms);
+                    pricedRooms.set(raw.hotelId, priced);
+                    if (!priced.some((p) => p.res.ok))
+                        why.set(raw.hotelId, noRoomsWhy(priced, stay, wantRooms));
+                }
+                catch (err) {
+                    pricedRooms.set(raw.hotelId, []);
+                    why.set(raw.hotelId, err instanceof HuazhuRefusal && err.code === 2009
+                        ? 'Huazhu is answering slowly just now; open the hotel for its rooms.'
+                        : 'Prices could not be read from Huazhu just now; open the hotel for its rooms.');
+                }
+            };
+            const bestFor = (raw, over) => {
+                const k = bestKey(raw.hotelId, over);
+                const known = best.get(k);
+                if (known !== undefined)
+                    return known;
+                let found = null;
+                for (const p of pricedRooms.get(raw.hotelId) ?? []) {
+                    if (!p.res.ok || !stay)
+                        continue;
+                    const room = toRoom(raw, p, stay);
+                    if (over.freeCancellation && !room.freeCancellationUntil)
+                        continue;
+                    if (over.breakfast && !room.breakfast)
+                        continue;
+                    if (!found || room.stayTotal.minor < found.room.stayTotal.minor)
+                        found = { room, name: room.name };
+                }
+                best.set(k, found);
+                return found;
+            };
+            if (priceEverything)
+                await pool(matches.map((m) => m.raw), PRICE_CONCURRENCY, priceHotel);
+            const canRoomFilter = priceEverything;
+            if (canRoomFilter && roomTerms)
+                matches = matches.filter(({ raw }) => bestFor(raw, f) !== null);
+            const currencies = [...new Set(matches.map((m) => m.hotel.currency))].sort();
+            const onePrice = currencies.length === 1;
+            const ceiling = priceEverything && onePrice && Number(q.maxNightly) > 0 ? Number(q.maxNightly) : undefined;
+            const nightlyOf = (raw) => {
+                const b = bestFor(raw, f);
+                return b ? b.room.nightly.minor / minorFactor(b.room.nightly.currency) : undefined;
+            };
+            const under = (raw) => {
+                if (ceiling === undefined)
+                    return true;
+                const n = nightlyOf(raw);
+                return n !== undefined && n <= ceiling;
+            };
+            // Group order: the cities with the most hotels first - the same rule as
+            // every other deployment, and a fact about the data rather than a pick.
+            const citySize = new Map();
+            for (const m of matches)
+                citySize.set(m.hotel.cityId, (citySize.get(m.hotel.cityId) ?? 0) + 1);
+            const manyCities = citySize.size > 1;
+            const ranked = manyCities
+                ? [...matches].sort((a, b) => (citySize.get(b.hotel.cityId) ?? 0) - (citySize.get(a.hotel.cityId) ?? 0) ||
+                    a.hotel.cityId.localeCompare(b.hotel.cityId))
+                : matches;
+            const passed = ranked.filter(({ raw }) => under(raw));
+            const over = ceiling === undefined
+                ? []
+                : ranked.filter(({ raw }) => !under(raw) && nightlyOf(raw) !== undefined);
+            const priceKey = (raw) => {
+                const b = bestFor(raw, f);
+                return b ? b.room.stayTotal.minor * wantRooms : undefined;
+            };
+            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 sort = q.sort ?? 'group';
+            const ordered = (sort === 'price-low' || sort === 'price-high') && priceEverything && onePrice
+                ? [...passed].sort((a, b) => byPrice(a.raw, b.raw, sort === 'price-low' ? 1 : -1))
+                : passed;
+            if (sort === 'rating') {
+                unapplied.push('Huazhu publishes no guest ratings, so there is no rating order.');
+                ignored.sort = true;
+            }
+            const page = Math.max(1, Math.min(MAX_PAGE, Math.floor(Number(q.limit) > 0 ? Number(q.limit) : DEFAULT_PAGE)));
+            const from = Math.max(0, Math.floor(Number(q.offset) > 0 ? Number(q.offset) : 0));
+            const shown = ordered.slice(from, from + page);
+            // The page is priced whatever else was: it is what the guest sees.
+            if (stay && !priceEverything)
+                await pool(shown.map((m) => m.raw), PRICE_CONCURRENCY, priceHotel);
+            const priced = (m) => {
+                if (!stay)
+                    return m.hotel;
+                const b = bestFor(m.raw, f);
+                if (!b)
+                    return {
+                        ...m.hotel,
+                        noRoomsForStay: why.get(m.raw.hotelId) ?? 'No room here can be booked for those nights.',
+                    };
+                return {
+                    ...m.hotel,
+                    forStay: {
+                        total: multiplyMoney(b.room.stayTotal, wantRooms),
+                        nightly: b.room.nightly,
+                        room: b.name,
+                        rooms: wantRooms,
+                        nights: b.room.nights,
+                        roomsLeft: b.room.roomsLeft,
+                        freeCancellation: !!b.room.freeCancellationUntil,
+                    },
+                };
+            };
+            const tally = (key) => {
+                const counts = new Map();
+                for (const { hotel } of passed)
+                    counts.set(key(hotel), (counts.get(key(hotel)) ?? 0) + 1);
+                return [...counts.entries()]
+                    .map(([name, count]) => ({ name, count }))
+                    .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+            };
+            const count = (o) => placed.filter(({ hotel, raw }) => passesStatic(hotel, o) &&
+                (!(o.freeCancellation || o.breakfast) || (canRoomFilter && bestFor(raw, o) !== null)) &&
+                under(raw)).length;
+            const result = {
+                hotels: shown.map(priced),
+                total: passed.length,
+                currencies,
+                refine: {
+                    brands: [...new Set(placed.map((m) => m.hotel.brand))]
+                        .map((name) => ({ name, count: count({ ...f, brand: name }) }))
+                        .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name)),
+                    facilities: FACILITIES.map((x) => ({
+                        key: x.key,
+                        label: x.label,
+                        count: count({ ...f, facilities: [...new Set([...(f.facilities ?? []), x.key])] }),
+                    })),
+                    // Only when every match was priced: a count over part of a list is
+                    // a count of nothing in particular.
+                    freeCancellation: canRoomFilter ? count({ ...f, freeCancellation: true }) : 0,
+                    breakfast: canRoomFilter ? count({ ...f, breakfast: true }) : 0,
+                },
+                ...(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) => ({
+                        ...c,
+                        country: passed.find((m) => m.hotel.city === c.name)?.hotel.country,
+                    })),
+                },
+                ...(over.length ? { overBudget: over.length } : {}),
+                ...(passed.length === 0 && over.length
+                    ? {
+                        nearest: [...over]
+                            .sort((a, b) => byPrice(a.raw, b.raw, 1))
+                            .slice(0, 3)
+                            .map(priced),
+                    }
+                    : {}),
+                ...(unapplied.length ? { unapplied, ignored } : {}),
+            };
+            return result;
+        },
+        async getHotel(id, stay) {
+            const raw = findHotel(id);
+            if (!raw)
+                return null;
+            const detail = { hotel: toHotel(raw, view, now()) };
+            if (!stay)
+                return detail;
+            const problem = stayProblem(stay, today());
+            if (problem)
+                return { ...detail, noRooms: problem };
+            let priced;
+            try {
+                priced = await priceStay(raw, stay, 1);
+            }
+            catch (err) {
+                return {
+                    ...detail,
+                    stay,
+                    noRooms: `Huazhu could not be asked for this hotel's rooms just now (${err instanceof HuazhuRefusal ? err.huazhuMessage : 'no answer'}). Try again in a moment.`,
+                };
+            }
+            const rooms = priced
+                .filter((p) => p.res.ok)
+                .map((p) => toRoom(raw, p, stay))
+                .sort((a, b) => a.stayTotal.minor - b.stayTotal.minor);
+            return {
+                ...detail,
+                stay,
+                rooms,
+                ...(rooms.length === 0 ? { noRooms: noRoomsWhy(priced, stay, 1) } : {}),
+            };
+        },
+        async datesAround(id, stay, o) {
+            const raw = findHotel(id);
+            if (!raw)
+                return [];
+            const span = Math.max(0, Math.min(7, Math.floor(o.span)));
+            const rooms = Math.max(1, Math.floor(o.rooms));
+            const n = nightsBetween(stay.checkIn, stay.checkOut);
+            const from = today();
+            const first = addDays(stay.checkIn, -span) < from ? from : addDays(stay.checkIn, -span);
+            const last = addDays(stay.checkOut, span);
+            let ari;
+            let products;
+            try {
+                [products, ari] = await Promise.all([
+                    productsOf(raw.hotelId),
+                    ariFor(raw.hotelId, first, last),
+                ]);
+            }
+            catch {
+                return [];
+            }
+            const out = [];
+            for (let shift = -span; shift <= span; shift += 1) {
+                const checkIn = addDays(stay.checkIn, shift);
+                const checkOut = addDays(checkIn, n);
+                if (checkIn < from)
+                    continue;
+                const candidate = { ...stay, checkIn, checkOut };
+                if (stayProblem(candidate, from))
+                    continue;
+                const context = {
+                    checkIn,
+                    checkOut,
+                    adults: stay.guests,
+                    rooms,
+                    today: from,
+                    clock: clockAt(now(), opts.tz),
+                    paymentType: opts.paymentType,
+                    allowTags,
+                };
+                let cheapest;
+                for (const product of products) {
+                    if (!bookableNow(product.bookWindow, checkIn, context.clock))
+                        continue;
+                    const w = ari.get(roomIdOf(product));
+                    if (!w)
+                        continue;
+                    const roomType = (raw.hotelRoomTypeList ?? []).find((r) => r.roomTypeCode === product.roomTypeCode);
+                    const res = sell(product, w, roomType, context);
+                    if (!res.ok)
+                        continue;
+                    const total = money(res.after.reduce((a, b) => a + toMinor(b, res.currency), 0) * rooms, res.currency);
+                    if (!cheapest || total.minor < cheapest.minor)
+                        cheapest = total;
+                }
+                out.push({
+                    checkIn,
+                    checkOut,
+                    ...(cheapest ? { from: cheapest } : {}),
+                    ...(shift === 0 ? { chosen: true } : {}),
+                });
+            }
+            return out;
+        },
+        async signInMember() {
+            return null;
+        },
+        async rememberPreferences() {
+            return [];
+        },
+        async extrasFor() {
+            return [];
+        },
+        quote,
+        async requestBooking(trip, guest, who, requests) {
+            if (!guest.name.trim() || !guest.email.includes('@')) {
+                throw new Error("A booking needs the guest's name and an email to send it to.");
+            }
+            const contact = contactOf(guest);
+            if (typeof contact === 'string')
+                throw new Error(contact);
+            if (trip.lines.some((l) => l.kind !== 'room')) {
+                throw new Error('Nothing was booked. Huazhu hotels have no add-ons here - take them out of the trip and ask again.');
+            }
+            const live = store
+                .all()
+                .filter((b) => b.owners.includes(who.sessionId) &&
+                (b.status === 'confirmed' || b.status === 'requested') &&
+                b.stay.checkOut >= today()).length;
+            const { groups } = splitByStay(trip.lines);
+            const lines = groups.flat();
+            if (live + lines.length > MAX_HOLDS_PER_CONVERSATION) {
+                throw new Error(`Nothing was booked. This conversation already has ${live} live booking${live === 1 ? '' : 's'}, and ${MAX_HOLDS_PER_CONVERSATION} at once is the most - cancel one that is not needed, then ask again.`);
+            }
+            // Priced afresh, not from the cache: this is the price that will be sent.
+            const priced = await quoteLines({ lines }, true);
+            if (priced.dropped?.length || priced.sold.size !== lines.length) {
+                throw new Error(`Nothing was booked. ${(priced.dropped ?? []).map((d) => `${d.title}: ${d.why}`).join(' ')} The trip is as it was - take that out or change it, then ask again.`);
+            }
+            const clean = cleanRequests(requests);
+            const comment = commentOf(clean, guest.notes);
+            const plans = [];
+            for (const [i, line] of lines.entries()) {
+                const sold = priced.sold.get(i);
+                const qline = priced.lines[i];
+                if (line.kind !== 'room' || !sold || !qline)
+                    throw new Error('Nothing was booked: the trip changed while it was being priced.');
+                plans.push({ i, line, sold, qline });
+            }
+            for (const plan of plans) {
+                const s = plan.sold.res;
+                const title = `${plan.qline.hotelName} - ${plan.qline.title}`;
+                try {
+                    const out = await client.prebook({
+                        hotelId: plan.line.hotelId,
+                        checkinType: 'DAY',
+                        paymentType: opts.paymentType,
+                        reservations: [
+                            {
+                                roomTypeCode: plan.sold.product.roomTypeCode,
+                                rateCode: plan.sold.product.rateCode,
+                                checkin: plan.line.stay.checkIn,
+                                checkout: plan.line.stay.checkOut,
+                                amountAfterTax: s.after,
+                                ...(s.before ? { amountBeforeTax: s.before } : {}),
+                                currencyCode: s.currency,
+                                roomCount: plan.qline.quantity ?? 1,
+                                adultCount: plan.line.stay.guests,
+                            },
+                        ],
+                    });
+                    plan.token = out.preBookToken;
+                }
+                catch (err) {
+                    if (err instanceof HuazhuRefusal)
+                        throw new Error(`Nothing was booked. ${refusalWords(err, title, s.currency)}`);
+                    throw new Error(`Nothing was booked: Huazhu could not be reached to check ${title} (${err.message}). Asking again is safe.`);
+                }
+            }
+            const tripRef = randomUUID();
+            const made = [];
+            /** Undo what this trip booked, when a later stay of it failed. */
+            const takeBackAll = async () => {
+                const stuck = [];
+                for (const b of made) {
+                    store.update(b.id, { rollback: true });
+                    const row = store.get(b.id);
+                    if (!row)
+                        continue;
+                    if (row.pendingSince !== undefined)
+                        continue; // the reconciler cancels it if it turns up
+                    await reconciler.takeBack(row);
+                    if (store.get(b.id)?.status !== 'cancelled')
+                        stuck.push(`${row.hotelName} (${row.confirmationCode})`);
+                }
+                return stuck.length
+                    ? ` ${stuck.join(' and ')} could not be cancelled automatically and has been flagged for a person to cancel with the hotel.`
+                    : '';
+            };
+            for (const plan of plans) {
+                const s = plan.sold.res;
+                const rooms = plan.qline.quantity ?? 1;
+                const qTotal = plan.qline.total.minor;
+                const nightlyMinor = s.after.map((x) => toMinor(x, s.currency));
+                const allIn = nightlyMinor.reduce((a, b) => a + b, 0) * rooms;
+                const cur = s.currency;
+                const id = `hz_${randomUUID()}`;
+                const dres = distributorResId();
+                const row = {
+                    id,
+                    confirmationCode: dres,
+                    status: 'requested',
+                    createdAt: new Date(now()).toISOString(),
+                    hotelId: plan.line.hotelId,
+                    hotelName: plan.qline.hotelName,
+                    stay: plan.line.stay,
+                    guest,
+                    quote: {
+                        lines: [plan.qline],
+                        subtotal: money(qTotal, cur),
+                        taxesAndFees: money(allIn - qTotal, cur),
+                        total: money(allIn, cur),
+                        stay: plan.line.stay,
+                    },
+                    ...(clean ? { requests: clean } : {}),
+                    owners: [who.sessionId],
+                    distributorResId: dres,
+                    tripRef,
+                    paymentType: opts.paymentType,
+                    guaranteeCode: s.guaranteeCode,
+                    cancelCode: s.cancelCode,
+                    nightlyMinor,
+                    rooms,
+                    tz: opts.tz,
+                    roomTypeCode: plan.sold.product.roomTypeCode,
+                    rateCode: plan.sold.product.rateCode,
+                    // ⚠️ SET BEFORE THE CALL: a process that dies mid-call leaves a
+                    // record the reconciler follows up on restart.
+                    pendingSince: now(),
+                };
+                store.put(row);
+                made.push(row);
+                const reservation = {
+                    roomTypeCode: plan.sold.product.roomTypeCode,
+                    rateCode: plan.sold.product.rateCode,
+                    checkin: plan.line.stay.checkIn,
+                    checkout: plan.line.stay.checkOut,
+                    amountAfterTax: s.after,
+                    ...(s.before ? { amountBeforeTax: s.before } : {}),
+                    ...(s.rack ? { rackRate: s.rack } : {}),
+                    currencyCode: cur,
+                    roomCount: rooms,
+                    adultCount: plan.line.stay.guests,
+                    guaranteePolicyCode: s.guaranteeCode,
+                    ...(clean?.arrivingAt ? { estimatedArrivalTime: clean.arrivingAt } : {}),
+                    resGuest: [contact],
+                };
+                const request = {
+                    hotelId: plan.line.hotelId,
+                    checkinType: 'DAY',
+                    contactPerson: contact,
+                    distributorResId: dres,
+                    paymentType: opts.paymentType,
+                    reservations: [reservation],
+                    ...(comment ? { guestComment: comment } : {}),
+                    ...(plan.token ? { preBookToken: plan.token } : {}),
+                };
+                // ⚠️ ONLY A REFUSAL FROM HUAZHU MEANS "NOT BOOKED". Anything else -
+                // no answer, an answer that did not parse, our own code failing after
+                // the call - means it may exist, and is followed up by the consistency
+                // query, never written off.
+                let outcome = 'unknown';
+                let refusal;
+                let answer;
+                for (let attempt = 0; attempt < 2 && !answer && !refusal; attempt += 1) {
+                    try {
+                        answer = await client.book(request);
+                    }
+                    catch (err) {
+                        if (!(err instanceof HuazhuRefusal))
+                            break;
+                        // "Already exists" for OUR id: an earlier try got through.
+                        if (err.code === 5218 || err.code === 5221 || err.code === 5231)
+                            break;
+                        if (err.code === 2001 && attempt === 0) {
+                            // The documentation's own advice: retry a system error, same id.
+                            await sleep(1_000);
+                            continue;
+                        }
+                        refusal = err;
+                    }
+                }
+                if (answer) {
+                    // Outside the try: a failure to WRITE this down is not Huazhu
+                    // refusing it, and must not be recorded as one.
+                    store.update(id, {
+                        resId: answer.resId,
+                        ...(answer.resCode ? { resCode: answer.resCode } : {}),
+                        confirmationCode: answer.resId,
+                        status: 'confirmed',
+                        hotelStatus: 'HOTEL_RESERVATION',
+                        pendingSince: undefined,
+                    });
+                    outcome = 'booked';
+                }
+                else if (refusal) {
+                    outcome = 'refused';
+                }
+                if (outcome === 'refused') {
+                    // Never made at Huazhu: nothing to follow up, nothing to show.
+                    store.update(id, { pendingSince: undefined, status: 'failed' });
+                    made.pop();
+                    const before = made.length;
+                    const back = await takeBackAll();
+                    const title = `${plan.qline.hotelName} - ${plan.qline.title}`;
+                    throw new Error(`Nothing was booked. ${refusal ? refusalWords(refusal, title, cur) : `Huazhu did not accept ${title}.`}${before && !back ? ' The stays booked before it in this trip were cancelled again.' : ''}${back}`);
+                }
+                if (outcome === 'unknown') {
+                    const settled = await settle(store.get(id) ?? row);
+                    if (settled.pendingSince !== undefined || settled.status !== 'confirmed') {
+                        if (plans.length > 1 || settled.status === 'failed') {
+                            const back = await takeBackAll();
+                            if (settled.status === 'failed') {
+                                throw new Error(`Nothing was booked: Huazhu did not confirm ${plan.qline.hotelName}.${back}`);
+                            }
+                            throw new Error(`Nothing was booked: Huazhu did not answer in time for ${plan.qline.hotelName}, so the trip was stopped. If that booking turns up in the next few minutes it is cancelled automatically.${back}`);
+                        }
+                        // One stay, outcome still unknown: it is the guest's booking, marked
+                        // as waiting, and the reconciler settles it within eight minutes.
+                    }
+                }
+            }
+            return made.map((b) => publicBooking(store.get(b.id) ?? b));
+        },
+        async listBookings(who, limit = 10) {
+            const most = Math.max(1, Math.min(MAX_PAGE, Math.floor(Number(limit) > 0 ? limit : 10)));
+            const mine = store
+                .all()
+                .filter((b) => b.owners.includes(who.sessionId) &&
+                !(b.status === 'failed' && !b.resId && b.pendingSince === undefined && !b.attention))
+                .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+                .slice(0, most);
+            const fresh = await pool(mine, 3, (b) => refresh(b));
+            return fresh.map(publicBooking);
+        },
+        async findBooking(ref, who) {
+            const b = findOwn(ref, who);
+            return b ? publicBooking(await refresh(b)) : null;
+        },
+        async previewChange(ref, _change, who) {
+            const b = findOwn(ref, who);
+            if (!b)
+                return null;
+            const rooms = b.rooms;
+            return {
+                bookingId: b.id,
+                confirmationCode: b.confirmationCode,
+                hotelName: b.hotelName,
+                from: {
+                    stay: b.stay,
+                    rooms,
+                    roomName: b.quote.lines[0]?.title ?? '',
+                    total: b.quote.total,
+                },
+                changeable: false,
+                rule: "Huazhu's booking system does not move a booking to other nights or another room. To change it, cancel it - under its cancellation terms - and book the new nights.",
+            };
+        },
+        async changeBooking() {
+            throw new Error("Huazhu's booking system does not move a booking to other nights or another room. To change it, cancel it - under its cancellation terms - and book the new nights.");
+        },
+        async previewCancellation(ref, who) {
+            const found = findOwn(ref, who);
+            if (!found)
+                return null;
+            const b = await refresh(found);
+            const cur = b.quote.total.currency;
+            const zero = money(0, cur);
+            const past = now() >= nightAuditOf(b.stay.checkIn, b.tz);
+            if (b.pendingSince !== undefined) {
+                return {
+                    bookingId: b.id,
+                    confirmationCode: b.confirmationCode,
+                    fee: zero,
+                    refund: zero,
+                    rule: 'Huazhu has not confirmed this booking yet - that takes up to eight minutes. It can be cancelled once it is confirmed.',
+                    cancellable: false,
+                };
+            }
+            if (b.status !== 'confirmed' || past) {
+                return {
+                    bookingId: b.id,
+                    confirmationCode: b.confirmationCode,
+                    fee: zero,
+                    refund: zero,
+                    rule: past && b.status === 'confirmed'
+                        ? 'The arrival day has passed; a booking cannot be cancelled after it.'
+                        : `This booking is ${b.status}; there is nothing left to cancel.`,
+                    cancellable: false,
+                };
+            }
+            const { fee, forbidden, rule, freeUntil } = feeNow(b);
+            return {
+                bookingId: b.id,
+                confirmationCode: b.confirmationCode,
+                fee: money(forbidden ? 0 : fee, cur),
+                // Nothing was paid through this connector: there is nothing to refund.
+                refund: zero,
+                rule: forbidden
+                    ? `This rate cannot be cancelled now. ${rule}`
+                    : `${rule} Nothing was paid through this connector - the booking is paid at the hotel - so any fee is charged under the hotel's terms, and Huazhu works out the exact amount when it cancels.`,
+                ...(freeUntil ? { freeUntil: new Date(freeUntil).toISOString() } : {}),
+                cancellable: !forbidden,
+            };
+        },
+        async cancelBooking(ref, who) {
+            const found = findOwn(ref, who);
+            if (!found)
+                return null;
+            const b = await refresh(found);
+            if (b.status !== 'confirmed')
+                return publicBooking(b);
+            if (b.pendingSince !== undefined || !b.resId) {
+                throw new Error('Huazhu has not confirmed this booking yet - that takes up to eight minutes. It can be cancelled once it is confirmed.');
+            }
+            const cur = b.quote.total.currency;
+            try {
+                const out = await client.cancel(b.resId);
+                const fee = typeof out.penaltyAmount === 'number'
+                    ? money(toMinor(out.penaltyAmount, out.penaltyCurrencyCode || cur), out.penaltyCurrencyCode || cur)
+                    : money(feeNow(b).fee, cur);
+                return publicBooking(store.update(b.id, {
+                    status: 'cancelled',
+                    hotelStatus: 'HOTEL_CANCEL',
+                    cancelledAt: new Date(now()).toISOString(),
+                    cancellationFee: fee,
+                }) ?? b);
+            }
+            catch (err) {
+                if (err instanceof HuazhuRefusal && err.code === 5402) {
+                    return publicBooking(store.update(b.id, {
+                        status: 'cancelled',
+                        hotelStatus: 'HOTEL_CANCEL',
+                        cancelledAt: b.cancelledAt ?? new Date(now()).toISOString(),
+                    }) ?? b);
+                }
+                if (err instanceof HuazhuRefusal && (err.code === 5401 || err.code === 5405)) {
+                    throw new Error(err.code === 5405
+                        ? 'Huazhu says this stay has already started, so it cannot be cancelled.'
+                        : 'Huazhu says this booking cannot be cancelled.');
+                }
+                if (err instanceof HuazhuUnreachable) {
+                    throw new Error('Huazhu did not answer, so it is not known whether the booking was cancelled. Asking again is safe - cancelling twice does not charge twice.');
+                }
+                throw err;
+            }
+        },
+        async policies() {
+            // Huazhu publishes no policy text: each RATE carries its terms, and those
+            // are shown with the room and on the cancellation preview. Nothing here
+            // is written in the hotel's name.
+            return [];
+        },
+    };
+};
+/**
+ * Offers for one product from consecutive ARI answers, as one run of dates.
+ * A part with no offer for the product is a run of nulls, not a gap.
+ */
+const mergeOffers = (parts) => {
+    const base = parts.find((p) => p.offer)?.offer;
+    if (!base)
+        return undefined;
+    const run = (pick) => parts.flatMap((p) => {
+        const arr = p.offer ? pick(p.offer) : undefined;
+        return Array.from({ length: p.days }, (_, i) => (arr?.[i] ?? null));
+    });
+    const adults = [
+        ...new Set(parts.flatMap((p) => (p.offer?.rates ?? []).map((r) => r.maxAdultCount))),
+    ];
+    const rates = adults.map((a) => {
+        const of = (o) => o.rates.find((r) => r.maxAdultCount === a);
+        return {
+            maxAdultCount: a,
+            amountAfterTax: run((o) => of(o)?.amountAfterTax),
+            amountBeforeTax: run((o) => of(o)?.amountBeforeTax),
+            rackRate: run((o) => of(o)?.rackRate),
+        };
+    });
+    const r = (k) => run((o) => o.restriction?.[k]);
+    return {
+        roomTypeCode: base.roomTypeCode,
+        rateCode: base.rateCode,
+        currencyCode: base.currencyCode,
+        mealPlanType: base.mealPlanType,
+        mealPlanCounts: run((o) => o.mealPlanCounts),
+        rates,
+        restriction: {
+            close: r('close'),
+            minStayArrival: r('minStayArrival'),
+            maxStayArrival: r('maxStayArrival'),
+            minStayThrough: r('minStayThrough'),
+            maxStayThrough: r('maxStayThrough'),
+            minAdvanceDay: r('minAdvanceDay'),
+            maxAdvanceDay: r('maxAdvanceDay'),
+            cta: r('cta'),
+            ctd: r('ctd'),
+            fplos: r('fplos'),
+        },
+        guaranteePolicies: run((o) => o.guaranteePolicies),
+        cancelPolicies: run((o) => o.cancelPolicies),
+    };
+};
+//# sourceMappingURL=backend.js.map