@curless/hotel-storefront 0.27.7 → 0.27.9

package/dist/aggregate/hotels.js

@@ -0,0 +1,633 @@
+import { DEFAULT_PAGE, FULL_CAPABILITIES, MAX_PAGE, } from '../backend.js';
+import { NAMESPACE, shownFor, unwrap, wrap } from './ids.js';
+import { mergeKnown, pagePlan } from './paging.js';
+/** Codes remembered at once; the oldest go first. A code that is forgotten is still found by asking. */
+const MAX_ROUTES = 50_000;
+/**
+ * Which supplier holds the booking a code names.
+ *
+ * ⚠️ A CODE IS WHAT THE GUEST QUOTES, AND IT IS NOT RENAMED: it is the hotel's
+ * handle on the stay, printed on a confirmation. So a code reaches the market
+ * without a namespace, and this is how it finds its way back. Two suppliers
+ * can in principle mint the same code; the one that made it is asked first.
+ */
+class Routes {
+    file;
+    codes = new Map();
+    /** What each supplier's codes have been seen to start with - "SL-". */
+    prefixes = new Map();
+    constructor(file) {
+        this.file = file;
+        const saved = file?.read();
+        for (const [code, ns] of Object.entries(saved?.codes ?? {}))
+            this.learn(code, ns);
+        file?.bind(() => ({ codes: Object.fromEntries(this.codes) }));
+    }
+    get(code) {
+        return this.codes.get(code.trim().toUpperCase());
+    }
+    note(code, ns) {
+        const key = code.trim().toUpperCase();
+        if (!key || this.codes.get(key) === ns)
+            return;
+        this.learn(key, ns);
+        while (this.codes.size > MAX_ROUTES) {
+            const [oldest] = this.codes.keys();
+            if (oldest === undefined)
+                break;
+            this.codes.delete(oldest);
+        }
+        this.file?.changed();
+    }
+    learn(code, ns) {
+        const key = code.trim().toUpperCase();
+        this.codes.delete(key);
+        this.codes.set(key, ns);
+        const prefix = /^[A-Z0-9]{1,8}-/.exec(key)?.[0];
+        if (prefix)
+            this.prefixes.set(ns, (this.prefixes.get(ns) ?? new Set()).add(prefix));
+    }
+}
+/** A refusal the tools read back to the guest - see `guestWords` in tools.ts. */
+const refusal = (code, message) => Object.assign(new Error(message), { code });
+/**
+ * The market's identity for one supplier: everything but a member.
+ *
+ * ⚠️ A MEMBERSHIP IS ONE GROUP'S. The market signs nobody in (v1), but should a
+ * member ever ride along, one group's tier must not price another group's
+ * rooms - that is a discount neither group offered.
+ */
+const plain = (who) => {
+    if (!who)
+        return undefined;
+    const { member: _member, ...rest } = who;
+    return rest;
+};
+const listWords = (xs) => xs.length > 1 ? `${xs.slice(0, -1).join(', ')} and ${xs.at(-1)}` : (xs[0] ?? '');
+/**
+ * What the market as a whole can do: anything one of its suppliers can, so a
+ * tool is listed when some hotel here offers it - and never members (v1: two
+ * groups' programmes, and nothing in the tools that says which).
+ *
+ * ⚠️ `booking` CAN ONLY BE ONE WORD HERE, and a market can hold both. Until the
+ * tools read each hotel's own (香格里拉's step ③), a market that mixes them
+ * says `hold` - the one that promises less.
+ */
+export const marketCapabilities = (all) => ({
+    members: false,
+    extras: all.some((c) => c.extras),
+    changes: all.some((c) => c.changes),
+    booking: all.length > 0 && all.every((c) => c.booking === 'pay-at-hotel') ? 'pay-at-hotel' : 'hold',
+    ...(all.some((c) => c.policies !== false) ? {} : { policies: false }),
+    ...(all.some((c) => c.requiresPhone) ? { requiresPhone: true } : {}),
+    // One currency for EVERY hotel: two groups that each charge in one may not
+    // charge in the same one.
+    ...(all.length === 1 && all[0]?.oneCurrency ? { oneCurrency: true } : {}),
+});
+const clampPage = (raw) => Math.max(1, Math.min(MAX_PAGE, Math.floor(Number(raw) > 0 ? Number(raw) : DEFAULT_PAGE)));
+const clampOffset = (raw) => Math.max(0, Math.floor(Number(raw) > 0 ? Number(raw) : 0));
+/** The number a price order compares: the stay's total on named nights, the from-rate otherwise. */
+const priceOf = (h) => h.forStay?.total.minor ?? h.fromNightly?.minor;
+/** A hotel with no price, or no rating, goes last whichever way - as in every supplier's own order. */
+const orderBy = (sort) => (a, b) => {
+    if (sort === 'rating')
+        return (b.rating?.value ?? -1) - (a.rating?.value ?? -1);
+    const x = priceOf(a);
+    const y = priceOf(b);
+    if (x === undefined)
+        return y === undefined ? 0 : 1;
+    if (y === undefined)
+        return -1;
+    return sort === 'price-high' ? y - x : x - y;
+};
+const tally = (rows, key, name) => {
+    const out = new Map();
+    for (const row of rows) {
+        const k = key(row);
+        const was = out.get(k);
+        out.set(k, was ? { ...was, count: was.count + row.count } : { ...row });
+    }
+    return [...out.values()].sort((a, b) => b.count - a.count || name(a).localeCompare(name(b)));
+};
+/**
+ * A market's supplier ids, checked before anything is made from them: each
+ * goes on every id the market hands out and names a state directory.
+ */
+export const checkSupplierIds = (brand, ids) => {
+    if (ids.length === 0)
+        throw new Error(`${brand}: a market needs at least one supplier`);
+    for (const id of ids) {
+        if (!NAMESPACE.test(id)) {
+            throw new Error(`${brand}: supplier id "${id}" must be lower-case letters, digits and dashes - it goes on every id and names a directory`);
+        }
+    }
+    const dup = ids.find((id, i) => ids.indexOf(id) !== i);
+    if (dup)
+        throw new Error(`${brand}: two suppliers are called "${dup}"`);
+};
+export const createAggregateHotels = (opts) => {
+    const suppliers = opts.suppliers;
+    checkSupplierIds(opts.brand, suppliers.map((s) => s.id));
+    const known = new Set(suppliers.map((s) => s.id));
+    const byId = new Map(suppliers.map((s) => [s.id, s]));
+    /** One supplier's own capabilities, its programme and code prefix with them - but never members (v1). */
+    const capsOf = (s) => ({
+        ...(s.backend.capabilities ?? FULL_CAPABILITIES),
+        members: false,
+    });
+    const prefixOf = (s) => {
+        const p = (s.codePrefix ?? s.backend.capabilities?.codePrefix)?.toUpperCase();
+        return p ? (p.endsWith('-') ? p : `${p}-`) : undefined;
+    };
+    const capabilities = marketCapabilities(suppliers.map(capsOf));
+    const routes = new Routes(opts.routes);
+    /** The supplier `filters.supplier` names - by id or by name, as a guest or a model would say it. */
+    const supplierNamed = (raw) => {
+        const wanted = raw.trim().toLowerCase();
+        return suppliers.find((s) => s.id === wanted || s.name.toLowerCase() === wanted);
+    };
+    const hotelOut = (ns, h) => ({
+        ...h,
+        id: wrap(ns, h.id),
+        supplier: ns,
+    });
+    const lineOut = (ns, l) => ({ ...l, hotelId: wrap(ns, l.hotelId) });
+    const quoteOut = (ns, q) => ({
+        ...q,
+        lines: q.lines.map((l) => lineOut(ns, l)),
+    });
+    const bookingOut = (ns, b) => {
+        routes.note(b.confirmationCode, ns);
+        return {
+            ...b,
+            id: wrap(ns, b.id),
+            hotelId: wrap(ns, b.hotelId),
+            quote: quoteOut(ns, b.quote),
+            supplier: ns,
+        };
+    };
+    /**
+     * The supplier a hotel reference belongs to, and its own id there.
+     *
+     * ⚠️ A NAME IS LOOKED UP IN EVERY GROUP AND TAKEN ONLY WHEN IT IS ONE HOTEL.
+     * Each backend finds a hotel by its name as well as its id, loosely; asked
+     * across groups, "Shanghai" can be two hotels in two groups, and picking
+     * either is booking the guest somewhere they did not choose. Exactly one, or
+     * an exact name, or nothing.
+     */
+    const hotelRef = async (ref) => {
+        const own = unwrap(ref, known);
+        if (own) {
+            const s = byId.get(own.ns);
+            return s ? { s, id: own.id } : undefined;
+        }
+        const found = await Promise.all(suppliers.map(async (s) => {
+            try {
+                const d = await s.backend.getHotel(ref);
+                return d ? { s, hotel: d.hotel } : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        }));
+        const hits = found.filter((x) => !!x);
+        const exact = hits.filter((x) => x.hotel.name.toLowerCase() === ref.trim().toLowerCase());
+        const one = hits.length === 1 ? hits[0] : exact.length === 1 ? exact[0] : undefined;
+        return one ? { s: one.s, id: one.hotel.id } : undefined;
+    };
+    /**
+     * The suppliers that may hold a booking a reference names, most likely
+     * first: the one a namespace names; else the one that made the code, then
+     * those whose codes look like it - and only when none do, all of them.
+     */
+    const bookingCandidates = (ref) => {
+        const own = unwrap(ref, known);
+        if (own) {
+            const s = byId.get(own.ns);
+            return s ? [{ s, ref: own.id }] : [];
+        }
+        const code = ref.trim().toUpperCase();
+        const prefixes = (s) => [
+            ...(prefixOf(s) ? [prefixOf(s)] : []),
+            ...(routes.prefixes.get(s.id) ?? []),
+        ];
+        const mapped = routes.get(code);
+        const looksLike = suppliers.filter((s) => prefixes(s).some((p) => code.startsWith(p)));
+        const first = [
+            ...(mapped && byId.get(mapped) ? [byId.get(mapped)] : []),
+            ...looksLike,
+        ];
+        const order = first.length ? first : suppliers;
+        return [...new Set(order)].map((s) => ({ s, ref }));
+    };
+    /** The first supplier, most likely first, that answers for this booking reference. */
+    const firstAnswer = async (ref, ask) => {
+        for (const c of bookingCandidates(ref)) {
+            const value = await ask(c.s, c.ref);
+            if (value)
+                return { s: c.s, value };
+        }
+        return null;
+    };
+    /** A trip's lines by supplier, each with the market's prefix taken off. Lines naming no supplier here, apart. */
+    const splitTrip = (lines) => {
+        const parts = new Map();
+        const strays = [];
+        for (const l of lines) {
+            const own = unwrap(l.hotelId, known);
+            if (!own) {
+                strays.push(l);
+                continue;
+            }
+            parts.set(own.ns, [...(parts.get(own.ns) ?? []), { ...l, hotelId: own.id }]);
+        }
+        return { parts, strays };
+    };
+    const draftFor = (ns, lines, trip) => ({
+        lines,
+        ...(trip.shown ? { shown: shownFor(trip.shown, ns, known) } : {}),
+    });
+    /**
+     * A change this booking's group cannot make, answered as one - or nothing,
+     * when it can. Nights, rooms and the room type are `changes`; an add-on is
+     * `extras`.
+     */
+    const unchangeable = (s, b, change) => {
+        const caps = capsOf(s);
+        const stayAsked = change.checkIn !== undefined ||
+            change.checkOut !== undefined ||
+            change.rooms !== undefined ||
+            change.room !== undefined;
+        const extraAsked = change.extra !== undefined;
+        const rule = stayAsked && !caps.changes
+            ? `${s.name} cannot change a booking in place: for other nights or rooms, cancel this one and book again - the cancellation follows its own terms.`
+            : extraAsked && !caps.extras
+                ? `${s.name} sells no add-ons here, so none can be put on this booking.`
+                : undefined;
+        if (!rule)
+            return null;
+        const room = b.quote.lines.find((l) => l.kind === 'room');
+        return {
+            bookingId: wrap(s.id, b.id),
+            confirmationCode: b.confirmationCode,
+            hotelName: b.hotelName,
+            from: {
+                stay: b.stay,
+                rooms: room?.quantity ?? 1,
+                roomName: room?.title ?? '',
+                total: b.quote.total,
+            },
+            changeable: false,
+            rule,
+            supplier: s.id,
+        };
+    };
+    const searchHotels = async (q, who) => {
+        const asked = q.filters;
+        const { supplier: wantedName, ...rest } = asked ?? {};
+        const wanted = wantedName ? supplierNamed(wantedName) : undefined;
+        const filters = asked && Object.keys(rest).length > 0 ? rest : undefined;
+        const from = clampOffset(q.offset);
+        const page = clampPage(q.limit);
+        const sort = q.sort ?? 'group';
+        const ordered = sort !== 'group';
+        const active = wantedName ? (wanted ? [wanted] : []) : suppliers;
+        const others = suppliers.filter((s) => !active.includes(s));
+        const caller = plain(who);
+        const unapplied = [];
+        if (wantedName && !wanted) {
+            unapplied.push(`No hotel group here is called "${wantedName}" - the groups are ${listWords(suppliers.map((s) => s.name))}.`);
+        }
+        let base = { ...q, filters, offset: 0 };
+        const n = Math.max(1, active.length);
+        // The first ask: enough of each supplier's list for this page when the
+        // suppliers take turns (`ordered` false), or each one's first
+        // `from + page`, capped, when one order runs across them.
+        const firstWindow = ordered
+            ? { offset: 0, limit: Math.min(from + page, MAX_PAGE) }
+            : { offset: Math.floor(from / n), limit: Math.min(MAX_PAGE, Math.ceil(page / n) + 1) };
+        const ask = async (s, window) => s.backend.searchHotels({ ...base, ...window }, caller);
+        const round = async (list, window) => Promise.allSettled(list.map((s) => ask(s, window)));
+        let first = await round(active, firstWindow);
+        let counts = await round(others, { offset: 0, limit: 1 });
+        const okOf = (settled, list) => settled.flatMap((r, i) => {
+            const s = list[i];
+            return r.status === 'fulfilled' && s ? [{ s, k: i, result: r.value }] : [];
+        });
+        let answers = okOf(first, active);
+        // ⚠️ A PRICE CEILING IS IN ONE CURRENCY, AND EACH SUPPLIER APPLIED IT IN
+        // ITS OWN. Huazhu applying ¥800 and a Tokyo group applying ¥800 are two
+        // different ceilings with one number. Across currencies the market applies
+        // none - asked again without it - and the tools say so, as for one group.
+        const union = (rs) => [...new Set(rs.flatMap((a) => a.result.currencies))].sort();
+        if (Number(q.maxNightly) > 0 && union(answers).length > 1) {
+            const { maxNightly: _dropped, ...without } = base;
+            base = without;
+            first = await round(active, firstWindow);
+            counts = await round(others, { offset: 0, limit: 1 });
+            answers = okOf(first, active);
+        }
+        const down = first.flatMap((r, i) => (r.status === 'rejected' ? [active[i]] : []));
+        if (active.length > 0 && answers.length === 0) {
+            throw first.find((r) => r.status === 'rejected').reason;
+        }
+        for (const s of down) {
+            if (s)
+                unapplied.push(`${s.name}'s hotels could not be searched just now, so none of them is in this list.`);
+        }
+        if (down.length)
+            console.error('[market] search failed for', down.map((s) => s?.id).join(', '));
+        const currencies = union(answers);
+        const totals = active.map((s) => answers.find((a) => a.s === s)?.result.total ?? 0);
+        const got = active.map(() => new Map());
+        for (const a of answers) {
+            a.result.hotels.forEach((h, j) => got[a.k]?.set(firstWindow.offset + j, h));
+        }
+        // One order across suppliers, where it means something: a price order in
+        // one currency, or ratings - and only where every supplier applied it to
+        // its own list, because merging lists that are not in order is not an
+        // order.
+        const childIgnored = answers.some((a) => a.result.ignored?.sort);
+        const merging = ordered && !childIgnored && (sort === 'rating' || currencies.length <= 1);
+        const known = merging
+            ? mergeKnown(active.map((_, k) => {
+                const items = [];
+                for (let i = 0; got[k]?.has(i); i += 1)
+                    items.push(got[k]?.get(i));
+                return items;
+            }), totals, orderBy(sort))
+            : [];
+        // Biggest first when they take turns: the group with more of what was
+        // asked for opens the list. Ties keep the market's own order.
+        const turns = active
+            .map((_, k) => k)
+            .sort((a, b) => (totals[b] ?? 0) - (totals[a] ?? 0) || a - b);
+        const { slots, beyond } = pagePlan(known, totals, turns, from, page);
+        if (beyond) {
+            unapplied.push(`Past the first ${known.length}, hotels are in that order within each group and the groups take turns - ask with a city or a filter for one order all the way down.`);
+        }
+        // What the plan needs and the first ask did not bring.
+        for (let k = 0; k < active.length; k += 1) {
+            const need = slots.filter((x) => x.k === k && !got[k]?.has(x.i)).map((x) => x.i);
+            if (need.length === 0)
+                continue;
+            const s = active[k];
+            for (let lo = Math.min(...need), hi = Math.max(...need); lo <= hi; lo += MAX_PAGE) {
+                const limit = Math.min(MAX_PAGE, hi - lo + 1);
+                try {
+                    const more = await ask(s, { offset: lo, limit });
+                    more.hotels.forEach((h, j) => got[k]?.set(lo + j, h));
+                }
+                catch (err) {
+                    console.error(`[market] ${s.id} page from ${lo} failed:`, err);
+                }
+            }
+        }
+        const hotels = slots.flatMap((x) => {
+            const h = got[x.k]?.get(x.i);
+            const s = active[x.k];
+            return h && s ? [hotelOut(s.id, h)] : [];
+        });
+        const total = totals.reduce((a, b) => a + b, 0);
+        const results = answers.map((a) => a.result);
+        const sum = (f) => results.reduce((acc, r) => acc + (f(r) ?? 0), 0);
+        const refines = results.flatMap((r) => (r.refine ? [r.refine] : []));
+        const otherAnswers = okOf(counts, others);
+        const supplierCounts = suppliers.flatMap((s) => {
+            const a = answers.find((x) => x.s === s) ?? otherAnswers.find((x) => x.s === s);
+            return a ? [{ id: s.id, count: a.result.total }] : [];
+        });
+        const anyFilter = !!asked && Object.keys(asked).length > 0;
+        const nearest = total === 0
+            ? results
+                .flatMap((r, j) => {
+                const s = answers[j]?.s;
+                return s ? (r.nearest ?? []).map((h) => hotelOut(s.id, h)) : [];
+            })
+                .sort(currencies.length <= 1 ? orderBy('price-low') : () => 0)
+                .slice(0, 3)
+            : [];
+        const ignored = {
+            ...(results.some((r) => r.ignored?.sort) ? { sort: true } : {}),
+            ...(results.some((r) => r.ignored?.ceiling) ? { ceiling: true } : {}),
+            ...(results.some((r) => r.ignored?.roomTerms) ? { roomTerms: true } : {}),
+        };
+        const said = [...new Set([...results.flatMap((r) => r.unapplied ?? []), ...unapplied])];
+        return {
+            hotels,
+            total,
+            currencies,
+            refine: {
+                brands: tally(refines.flatMap((r) => r.brands), (b) => b.name, (b) => b.name),
+                facilities: tally(refines.flatMap((r) => r.facilities), (f) => f.key, (f) => f.key),
+                freeCancellation: refines.reduce((a, r) => a + r.freeCancellation, 0),
+                breakfast: refines.reduce((a, r) => a + r.breakfast, 0),
+                suppliers: supplierCounts,
+            },
+            ...(anyFilter
+                ? {
+                    beforeFilters: [...answers, ...otherAnswers].reduce((a, x) => a + (x.result.beforeFilters ?? x.result.total), 0),
+                }
+                : {}),
+            ...(results.some((r) => r.beforeCeiling !== undefined)
+                ? { beforeCeiling: sum((r) => r.beforeCeiling ?? r.total) }
+                : {}),
+            facets: {
+                countries: tally(results.flatMap((r) => r.facets?.countries ?? []), (c) => c.name, (c) => c.name),
+                cities: tally(results.flatMap((r) => r.facets?.cities ?? []), (c) => `${c.name}|${c.country ?? ''}`, (c) => c.name),
+            },
+            ...(sum((r) => r.overBudget) > 0 ? { overBudget: sum((r) => r.overBudget) } : {}),
+            ...(nearest.length ? { nearest } : {}),
+            ...(said.length ? { unapplied: said } : {}),
+            ...(Object.keys(ignored).length ? { ignored } : {}),
+        };
+    };
+    return {
+        brand: opts.brand,
+        capabilities,
+        suppliers: () => suppliers.map((s) => ({
+            id: s.id,
+            name: s.name,
+            ...(s.logoUrl ? { logoUrl: s.logoUrl } : {}),
+            mode: s.mode,
+            capabilities: capsOf(s),
+        })),
+        supplierOf: (hotelId) => unwrap(hotelId, known)?.ns,
+        searchHotels,
+        async getHotel(id, stay, who) {
+            const at = await hotelRef(id);
+            if (!at)
+                return null;
+            const d = await at.s.backend.getHotel(at.id, stay, plain(who));
+            return d ? { ...d, hotel: hotelOut(at.s.id, d.hotel) } : null;
+        },
+        async datesAround(id, stay, o, who) {
+            const at = await hotelRef(id);
+            return at ? at.s.backend.datesAround(at.id, stay, o, plain(who)) : [];
+        },
+        // ⚠️ NO MEMBERS IN THE MARKET (v1) - `capabilities.members` is false, so
+        // the tools never list a sign-in. Answered anyway, as nobody.
+        async signInMember() {
+            return null;
+        },
+        async rememberPreferences() {
+            return [];
+        },
+        // A group that sells no add-ons is not asked for them.
+        async extrasFor(hotelId, stay) {
+            const at = await hotelRef(hotelId);
+            if (!at || !capsOf(at.s).extras)
+                return [];
+            const extras = await at.s.backend.extrasFor(at.id, stay);
+            return extras.map((x) => ({ ...x, hotelId: wrap(at.s.id, x.hotelId) }));
+        },
+        /**
+         * A trip priced. The tools price one currency at a time, and one currency
+         * can be two groups' hotels - Shanghai is yuan at both - so each group
+         * prices its own lines and the totals are added: same currency, no rate.
+         */
+        async quote(trip, who) {
+            const { parts, strays } = splitTrip(trip.lines);
+            const caller = plain(who);
+            if (parts.size === 0) {
+                // An empty trip, or one whose hotels are no longer here.
+                const q = await suppliers[0].backend.quote({ lines: [] }, caller);
+                return strays.length
+                    ? {
+                        ...q,
+                        dropped: strays.map((l) => ({
+                            title: l.hotelId,
+                            why: 'That hotel is not in this market any more.',
+                        })),
+                    }
+                    : q;
+            }
+            const quotes = await Promise.all([...parts.entries()].map(async ([ns, lines]) => quoteOut(ns, await byId.get(ns).backend.quote(draftFor(ns, lines, trip), caller))));
+            const dropped = [
+                ...quotes.flatMap((q) => q.dropped ?? []),
+                ...strays.map((l) => ({
+                    title: l.hotelId,
+                    why: 'That hotel is not in this market any more.',
+                })),
+            ];
+            const [one] = quotes;
+            if (quotes.length === 1 && one)
+                return dropped.length ? { ...one, dropped } : one;
+            const currency = one?.total.currency ?? '';
+            if (quotes.some((q) => q.total.currency !== currency)) {
+                throw refusal('mixed-currency', `These hotels charge in ${listWords([...new Set(quotes.map((q) => q.total.currency))])}; a trip is priced one currency at a time.`);
+            }
+            const add = (f) => quotes.reduce((a, q) => a + f(q), 0);
+            // Taxes given apart by one group and included by the other cannot be
+            // shown as one split: the whole is said to include them, which is true.
+            const included = quotes.some((q) => q.taxesIncluded);
+            const stays = quotes.map((q) => q.stay);
+            const sameStay = stays.every((s) => s) &&
+                new Set(stays.map((s) => `${s?.checkIn}|${s?.checkOut}|${s?.guests}`)).size === 1;
+            return {
+                lines: quotes.flatMap((q) => q.lines),
+                subtotal: {
+                    minor: included ? add((q) => q.total.minor) : add((q) => q.subtotal.minor),
+                    currency,
+                },
+                taxesAndFees: { minor: included ? 0 : add((q) => q.taxesAndFees.minor), currency },
+                ...(included ? { taxesIncluded: true } : {}),
+                total: { minor: add((q) => q.total.minor), currency },
+                ...(sameStay && stays[0] ? { stay: stays[0] } : {}),
+                ...(dropped.length ? { dropped } : {}),
+            };
+        },
+        /**
+         * ⚠️ ONE GROUP PER BOOKING (v1). Each group holds or books under its own
+         * rules, its own limits and its own codes, and "all of them or none" -
+         * the rule every backend keeps for a trip - cannot be kept across two
+         * systems that do not know about each other: the second refusing after the
+         * first booked leaves half a trip. So a trip with two groups' hotels is
+         * refused whole, before anybody is asked.
+         */
+        async requestBooking(trip, guest, who, requests) {
+            const { parts, strays } = splitTrip(trip.lines);
+            if (strays.length) {
+                throw refusal('not-found', 'Nothing was booked: a hotel in this trip is not in this market any more. Take it out of the trip and ask again.');
+            }
+            if (parts.size > 1) {
+                const groups = [...parts.entries()].map(([ns, lines]) => {
+                    const hotels = new Set(lines.map((l) => l.hotelId)).size;
+                    return `${hotels} ${hotels === 1 ? 'hotel' : 'hotels'} with ${byId.get(ns)?.name ?? ns}`;
+                });
+                throw refusal('mixed-supplier', `Nothing was booked: this trip has ${listWords(groups)}, and a booking here is made with one hotel group at a time. Take one group's hotels out of the trip, book the rest, then add them back and book them.`);
+            }
+            // An empty trip is the first supplier's to refuse, in its own words.
+            const [ns, lines] = [...parts.entries()][0] ?? [suppliers[0].id, []];
+            const made = await byId.get(ns).backend.requestBooking(draftFor(ns, lines, trip), guest, plain(who), requests);
+            return made.map((b) => bookingOut(ns, b));
+        },
+        /** Every group's, newest first - the order each keeps its own in. */
+        async listBookings(who, limit = 10) {
+            const most = Math.max(1, Math.min(MAX_PAGE, Math.floor(Number(limit) > 0 ? limit : 10)));
+            const caller = plain(who);
+            const settled = await Promise.allSettled(suppliers.map((s) => s.backend.listBookings(caller, most)));
+            const failed = settled.filter((r) => r.status === 'rejected');
+            if (failed.length === settled.length)
+                throw failed[0].reason;
+            if (failed.length)
+                console.error('[market] listing bookings failed for', failed.length, 'supplier(s)');
+            return settled
+                .flatMap((r, i) => {
+                const s = suppliers[i];
+                return r.status === 'fulfilled' && s ? r.value.map((b) => bookingOut(s.id, b)) : [];
+            })
+                .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+                .slice(0, most);
+        },
+        async findBooking(ref, who) {
+            const caller = plain(who);
+            const hit = await firstAnswer(ref, (s, r) => s.backend.findBooking(r, caller));
+            return hit ? bookingOut(hit.s.id, hit.value) : null;
+        },
+        /**
+         * ⚠️ A GROUP THAT CANNOT DO IT IS NOT ASKED. A market lists the change
+         * tools when any of its groups can change a booking; one that cannot is
+         * answered here, from its own booking, as a change that cannot be made -
+         * never with a call it has no answer for.
+         */
+        async previewChange(ref, change, who) {
+            const caller = plain(who);
+            const found = await firstAnswer(ref, (s, r) => s.backend.findBooking(r, caller));
+            if (!found)
+                return null;
+            const { s } = found;
+            const refused = unchangeable(s, found.value, change);
+            if (refused)
+                return refused;
+            const p = await s.backend.previewChange(found.value.id, change, caller);
+            return p ? { ...p, bookingId: wrap(s.id, p.bookingId), supplier: s.id } : null;
+        },
+        async changeBooking(ref, change, who) {
+            const caller = plain(who);
+            const found = await firstAnswer(ref, (s, r) => s.backend.findBooking(r, caller));
+            if (!found || unchangeable(found.s, found.value, change))
+                return null;
+            const b = await found.s.backend.changeBooking(found.value.id, change, caller);
+            return b ? bookingOut(found.s.id, b) : null;
+        },
+        async previewCancellation(ref, who) {
+            const caller = plain(who);
+            const hit = await firstAnswer(ref, (s, r) => s.backend.previewCancellation(r, caller));
+            return hit
+                ? { ...hit.value, bookingId: wrap(hit.s.id, hit.value.bookingId), supplier: hit.s.id }
+                : null;
+        },
+        async cancelBooking(ref, who, reason) {
+            const caller = plain(who);
+            const hit = await firstAnswer(ref, (s, r) => s.backend.cancelBooking(r, caller, reason));
+            return hit ? bookingOut(hit.s.id, hit.value) : null;
+        },
+        // A group that publishes no policy text is not asked for it.
+        async policies(hotelId) {
+            const at = await hotelRef(hotelId);
+            return at && capsOf(at.s).policies !== false ? at.s.backend.policies(at.id) : [];
+        },
+    };
+};
+//# sourceMappingURL=hotels.js.map