@curless/hotel-storefront 0.27.5 → 0.27.6

package/dist/__tests__/demo-hotels.test.js

@@ -1,765 +0,0 @@
-import { fileURLToPath } from 'node:url';
-import { beforeEach, describe, expect, it } from 'vitest';
-import { MAX_PAGE } from '../backend.js';
-import { loadHotelData } from '../data.js';
-import { byWords, createDemoHotels } from '../demo-hotels.js';
-// The brand's REAL data file, not a fixture: a demo backend whose tests pass on
-// invented input tells us nothing about what the connector will actually serve,
-// and this doubles as the guard that hotels.json still parses.
-const DATA = loadHotelData(fileURLToPath(new URL('./__fixtures__/brand.json', import.meta.url)));
-const OCT_1 = Date.parse('2026-10-01T02:00:00Z'); // 10:00 in Hong Kong
-const MON_WED = { checkIn: '2026-10-19', checkOut: '2026-10-21', guests: 2 };
-const FRI_SUN = { checkIn: '2026-10-16', checkOut: '2026-10-18', guests: 2 };
-const me = { sessionId: 'session-a' };
-/** A booking the call was sure to make - one stay in, one booking out. */
-const none = () => {
-    throw new Error('no booking came back');
-};
-const guest = { name: 'Robin Ruan', email: 'robin@example.com' };
-let clock = OCT_1;
-const make = () => createDemoHotels({ data: DATA, now: () => clock, rng: () => 0.5 });
-beforeEach(() => {
-    clock = OCT_1;
-});
-describe('searching', () => {
-    it('answers a city with every hotel in it - a city is not a hotel', async () => {
-        const found = await make().searchHotels({ city: 'hong-kong' });
-        expect(found.hotels).toHaveLength(4);
-        expect(new Set(found.hotels.map((h) => h.brand))).toEqual(new Set(['Shangri-La', 'Kerry', 'JEN']));
-    });
-    it('matches free text across name, area and amenities', async () => {
-        const hotels = make();
-        expect((await hotels.searchHotels({ query: 'pudong' })).hotels.map((h) => h.id)).toContain('shanghai-pudong');
-        expect((await hotels.searchHotels({ query: 'harbour views' })).hotels.length).toBeGreaterThan(1);
-        const none = await hotels.searchHotels({ query: 'reykjavik' });
-        expect(none.hotels).toEqual([]);
-        expect(none.total).toBe(0);
-    });
-    // ⚠️ The count and the page are two numbers now that the file holds ninety-odd
-    // hotels. They were the same while it held nine, and a search that returned
-    // only the page would have the card announce "20 hotels" about a group with
-    // forty in China - a made-up number in the one place that must not have one.
-    it('says how many matched, not how many fit on the page', async () => {
-        const all = await make().searchHotels({});
-        const some = await make().searchHotels({ limit: 2 });
-        expect(some.hotels).toHaveLength(2);
-        expect(some.total, 'total counts the matches, not the page').toBe(all.total);
-        expect(some.total).toBeGreaterThan(2);
-    });
-    it('takes a country where a city is asked for, because that is how a guest narrows a map', async () => {
-        const hk = await make().searchHotels({ city: 'Hong Kong SAR' });
-        expect(hk.total).toBe(4);
-        expect(new Set(hk.hotels.map((h) => h.cityId))).toEqual(new Set(['hong-kong']));
-        // …and as free text, where it also has to beat the city of the same name.
-        const china = await make().searchHotels({ query: 'china' });
-        expect(china.hotels.length).toBeGreaterThan(1);
-        expect(new Set(china.hotels.map((h) => h.country))).toContain('China');
-    });
-    // ⚠️ `slice(0, limit)` TOOK WHATEVER ARRIVED. A negative limit is
-    // `slice(0, -3)`, which returned ninety-THREE hotels, and limit 500 put all
-    // ninety-six - seventy kilobytes of JSON - into the model's context.
-    it('will not hand back the whole group however the limit is written', async () => {
-        const hotels = make();
-        const everything = (await hotels.searchHotels({})).total;
-        // Nothing above the ceiling, whatever was asked for - and a NEGATIVE limit
-        // is the one that mattered: `slice(0, -3)` quietly dropped the last three.
-        expect((await hotels.searchHotels({ limit: 500 })).hotels.length).toBe(Math.min(MAX_PAGE, everything));
-        expect((await hotels.searchHotels({ limit: -3 })).hotels.length).toBe(everything);
-        expect((await hotels.searchHotels({ limit: 0 })).hotels.length).toBe(everything);
-        expect((await hotels.searchHotels({ limit: 3 })).hotels.length).toBe(3);
-        // …and it still says how many there really are.
-        expect((await hotels.searchHotels({ limit: 3 })).total).toBe(everything);
-    });
-    // ⚠️ WHICH TWENTY OF NINETY-SIX. In file order an unnarrowed browse opens on
-    // Abu Dhabi, Bangkok, Baotou, Beihai - the alphabet, which says nothing about
-    // where this group is. The rule is the cities with the most properties first,
-    // it is stated in the tool description, and it is off the moment the guest
-    // narrows to a city or a country.
-    it('opens on the cities the group is biggest in, and stops ranking once asked', async () => {
-        const hotels = make();
-        // Hong Kong has four here, more than any other city, so it opens the list.
-        const first = await hotels.searchHotels({ limit: 4 });
-        expect(first.hotels.map((h) => h.cityId)).toEqual(Array(4).fill('hong-kong'));
-        // A city was asked for: every hotel in it, in the FILE's own order - not
-        // the ranking above, and not alphabetical. Compared against the file rather
-        // than a copied-out list, so a reordered brand file cannot make this test
-        // assert an order nobody chose.
-        const hk = await hotels.searchHotels({ city: 'hong-kong' });
-        expect(hk.hotels.map((h) => h.id)).toEqual(DATA.hotels.filter((h) => h.cityId === 'hong-kong').map((h) => h.id));
-        expect(hk.hotels.length).toBe(4);
-    });
-    // ⚠️ THE GUEST'S CLOCK IS NOT THE HOTEL'S. The card filled its dates from
-    // `toISOString()` - UTC - so a guest in Beijing before 8am was offered
-    // yesterday and the server refused it as past. The hotel's own date now
-    // travels with the hotel.
-    it('tells each hotel what day it is where it stands', async () => {
-        // 21:00 UTC: already tomorrow in Hong Kong (+08) and in Fiji (+12), still
-        // today in Paris, still yesterday's date in Toronto. The fixture is one
-        // zone, so the other two hotels are given theirs here - what is under test
-        // is that the date follows the HOTEL and not the machine.
-        const at = Date.parse('2026-10-01T21:00:00Z');
-        const [first, second, third] = DATA.hotels;
-        if (!first || !second || !third)
-            throw new Error('the fixture needs three hotels');
-        const spread = {
-            ...DATA,
-            hotels: [
-                first,
-                { ...second, utcOffset: 'Europe/Paris' },
-                { ...third, utcOffset: 'America/Toronto' },
-            ],
-        };
-        const hotels = createDemoHotels({ data: spread, now: () => at });
-        const day = async (id) => (await hotels.getHotel(id))?.hotel.todayThere;
-        expect(await day(String(first?.id))).toBe('2026-10-02');
-        expect(await day(String(second?.id))).toBe('2026-10-01');
-        expect(await day(String(third?.id))).toBe('2026-10-01');
-    });
-    it('shows a from-price per hotel but no stay price, because nobody gave dates', async () => {
-        const { hotels } = await make().searchHotels({ query: 'jen hong kong' });
-        expect(hotels[0]?.fromNightly).toEqual({ minor: 89_000, currency: 'HKD' }); // the pay-now rate, HK$890
-    });
-});
-// ⚠️ A MISSED NAME COSTS A SEARCH AND A SECOND CARD (robin, 2026-09-29): asked
-// for a plan, the model wrote "Jing An Shangri-La, West Shanghai", nothing
-// answered, and it listed the city and drew the plan again. The names below
-// are the group's own.
-describe('a hotel by the words of its name', () => {
-    const names = [
-        { id: 'shanghai-jingan', name: 'Jing An Shangri-La, Shanghai' },
-        { id: 'shanghai-pudong', name: 'Pudong Shangri-La, Shanghai' },
-        { id: 'shanghai-kerry-pudong', name: 'Kerry Hotel Pudong, Shanghai' },
-        { id: 'singapore-shangrila', name: 'Shangri-La Singapore' },
-        { id: 'singapore-rasasentosa', name: 'Shangri-La Rasa Sentosa, Singapore' },
-        { id: 'hong-kong-island', name: 'Island Shangri-La, Hong Kong' },
-    ];
-    const at = (text) => byWords(names, text)?.id;
-    it('takes every word of a name with one more, or fewer words that only one name has', () => {
-        expect(at('Jing An Shangri-La, West Shanghai')).toBe('shanghai-jingan');
-        expect(at('Shangri-La Hotel Singapore')).toBe('singapore-shangrila');
-        expect(at('Island Shangri-La Hong Kong')).toBe('hong-kong-island');
-        expect(at('Shangri-La Pudong')).toBe('shanghai-pudong');
-        expect(at('Rasa Sentosa')).toBe('singapore-rasasentosa');
-    });
-    it('never guesses between two hotels, and a sentence about one is not its name', () => {
-        expect(at('Shangri-La Shanghai')).toBeUndefined();
-        expect(at('Pudong Shanghai')).toBeUndefined();
-        expect(at('Shangri-La')).toBeUndefined();
-        expect(at('Airport transfer to Jing An Shangri-La, Shanghai')).toBeUndefined();
-        expect(at('Breakfast for two')).toBeUndefined();
-    });
-    it('is how the backend finds a hotel it was given by such a name', async () => {
-        const h = await make().getHotel('Jing An Shangri-La, West Shanghai');
-        expect(h?.hotel.id).toBe('shanghai-jingan');
-    });
-});
-describe('a hotel, with and without dates', () => {
-    it('has no rooms and no prices until someone names the nights', async () => {
-        const detail = await make().getHotel('hong-kong-island');
-        expect(detail?.hotel.name).toBe('Island Shangri-La, Hong Kong');
-        expect(detail?.rooms).toBeUndefined();
-        expect(detail?.stay).toBeUndefined();
-    });
-    it('prices the stay exactly, tax split out', async () => {
-        const detail = await make().getHotel('hong-kong-island', MON_WED);
-        const room = detail?.rooms?.find((r) => r.id === 'deluxe-city');
-        expect(room).toMatchObject({
-            nights: 2,
-            nightly: { minor: 380_000, currency: 'HKD' }, // HK$3,800 a night, no weekend in it
-            taxesAndFees: { minor: 98_800, currency: 'HKD' }, // 13% of HK$7,600
-            stayTotal: { minor: 858_800, currency: 'HKD' },
-        });
-    });
-    it('charges the Friday and Saturday more, and says so in the average', async () => {
-        const detail = await make().getHotel('hong-kong-island', FRI_SUN);
-        const room = detail?.rooms?.find((r) => r.id === 'deluxe-city');
-        // HK$3,800 x 1.2 on both nights, and 13% of HK$9,120 to the dollar.
-        expect(room?.nightly).toEqual({ minor: 456_000, currency: 'HKD' });
-        expect(room?.stayTotal).toEqual({ minor: 1_030_600, currency: 'HKD' });
-    });
-    it('gives a free-cancellation deadline counted back from arrival, and none on a rate that has none', async () => {
-        const rooms = (await make().getHotel('hong-kong-island', MON_WED))?.rooms ?? [];
-        // 48 hours before 15:00 on the 19th, Hong Kong time.
-        expect(rooms.find((r) => r.id === 'deluxe-city')?.freeCancellationUntil).toBe('2026-10-17T07:00:00.000Z');
-        expect(rooms.find((r) => r.id === 'horizon-club')?.freeCancellationUntil).toBeUndefined();
-        expect(rooms.find((r) => r.id === 'horizon-club')?.refundable).toBe(false);
-    });
-    it('says why rather than showing a room that cannot hold the party', async () => {
-        const detail = await make().getHotel('hong-kong-island', { ...MON_WED, guests: 5 });
-        expect(detail?.rooms).toBeUndefined();
-        // ceil(5 / 3), worked out - "two rooms would work" was written in.
-        expect(detail?.noRooms).toContain('the largest sleeps 3, so it takes 2 rooms');
-    });
-    it('hands a bad date straight back instead of pricing something else', async () => {
-        const detail = await make().getHotel('hong-kong-island', {
-            checkIn: '2026-09-01',
-            checkOut: '2026-09-03',
-            guests: 2,
-        });
-        expect(detail?.noRooms).toContain('in the past');
-        expect(detail?.rooms).toBeUndefined();
-    });
-    it('finds a hotel by its name as well as its id, because a model will type the name', async () => {
-        expect((await make().getHotel('Kowloon Shangri-La, Hong Kong'))?.hotel.id).toBe('hong-kong-kowloon');
-        expect(await make().getHotel('a hotel in paris')).toBeNull();
-    });
-});
-describe('pricing a trip', () => {
-    it('adds add-ons by their own unit and taxes the lot once', async () => {
-        const quote = await make().quote({
-            lines: [
-                { kind: 'room', hotelId: 'hong-kong-island', roomId: 'deluxe-city', stay: MON_WED },
-                { kind: 'extra', hotelId: 'hong-kong-island', extraId: 'peak-walk', quantity: 2 },
-            ],
-        });
-        // HK$7,600 of room + HK$680 x 2 of walk, then 13% on top - HK$1,164.80,
-        // rounded once to the dollar.
-        expect(quote.subtotal).toEqual({ minor: 896_000, currency: 'HKD' });
-        expect(quote.taxesAndFees).toEqual({ minor: 116_500, currency: 'HKD' });
-        expect(quote.total).toEqual({ minor: 1_012_500, currency: 'HKD' });
-        expect(quote.stay).toEqual(MON_WED);
-        expect(quote.lines.find((l) => l.kind === 'extra')?.quantity).toBe(2);
-    });
-    it('refuses to invent an exchange rate when a trip crosses currencies', async () => {
-        const quote = await make().quote({
-            lines: [
-                { kind: 'room', hotelId: 'hong-kong-island', roomId: 'deluxe-city', stay: MON_WED },
-                { kind: 'room', hotelId: 'shanghai-pudong', roomId: 'deluxe-city', stay: MON_WED },
-            ],
-        });
-        expect(quote.lines).toHaveLength(1);
-        expect(quote.dropped?.[0]?.why).toContain('exchange rate');
-        expect(quote.total.currency).toBe('HKD');
-    });
-    it('drops what is gone with a reason rather than quietly repricing', async () => {
-        const quote = await make().quote({
-            lines: [{ kind: 'room', hotelId: 'hong-kong-island', roomId: 'presidential', stay: MON_WED }],
-        });
-        expect(quote.lines).toHaveLength(0);
-        expect(quote.dropped?.[0]?.why).toContain('no longer listed');
-        expect(quote.total.minor).toBe(0);
-    });
-});
-describe('requesting a booking', () => {
-    const trip = {
-        lines: [
-            {
-                kind: 'room',
-                hotelId: 'hong-kong-island',
-                roomId: 'suite',
-                stay: { ...MON_WED, guests: 3 },
-            },
-        ],
-    };
-    it('takes no money, holds the room and says when the hold lapses', async () => {
-        const [booking = none()] = await make().requestBooking(trip, guest, me);
-        expect(booking.status).toBe('requested');
-        expect(booking.confirmationCode).toMatch(/^SL-[A-Z0-9]{6}$/);
-        expect(booking.holdUntil).toBe('2026-10-01T04:00:00.000Z'); // two hours
-        expect(booking.quote.total.minor).toBeGreaterThan(0);
-    });
-    it('never holds a room past the moment the guest could walk in', async () => {
-        clock = Date.parse('2026-10-19T04:00:00Z'); // arrival is 15:00 in Hong Kong, 07:00Z
-        const [booking = none()] = await make().requestBooking(trip, guest, me);
-        expect(booking.holdUntil).toBe('2026-10-19T05:00:00.000Z');
-    });
-    it('takes the held room off what the next guest is shown, and gives it back when the hold lapses', async () => {
-        const hotels = make();
-        await hotels.requestBooking(trip, guest, me); // the only suite
-        const held = await hotels.getHotel('hong-kong-island', { ...MON_WED, guests: 3 });
-        expect(held?.rooms).toEqual([]);
-        expect(held?.noRooms).toContain('taken');
-        clock = Date.parse('2026-10-01T06:00:00Z'); // past the two-hour hold
-        const back = await hotels.getHotel('hong-kong-island', { ...MON_WED, guests: 3 });
-        expect(back?.rooms?.map((r) => r.id)).toEqual(['suite']);
-    });
-    it('will not book a trip with nothing to sleep in', async () => {
-        await expect(make().requestBooking({
-            lines: [
-                { kind: 'extra', hotelId: 'hong-kong-island', extraId: 'peak-walk', quantity: 1 },
-            ],
-        }, guest, me)).rejects.toThrow(/An add-on goes with a stay, and this trip has no room night/);
-    });
-});
-// ⚠️ A TRIP OF MORE THAN ONE STAY (2026-09-28 audit). It became ONE booking
-// named after the first hotel, and "add a night" on it moved Beijing's room to
-// Shanghai; a leg that could not be held was left out without a word.
-describe('a trip of more than one stay', () => {
-    const room = (hotelId, roomId, checkIn, checkOut, rooms = 1) => ({
-        kind: 'room',
-        hotelId,
-        roomId,
-        rooms,
-        stay: { checkIn, checkOut, guests: 2 },
-    });
-    const extra = (hotelId, extraId, quantity = 1) => ({
-        kind: 'extra',
-        hotelId,
-        extraId,
-        quantity,
-    });
-    const other = { sessionId: 'session-b' };
-    it('is one booking per hotel stay, each with its own code, in the order of the stays', async () => {
-        const hotels = make();
-        const made = await hotels.requestBooking({
-            lines: [
-                room('beijing-china-world', 'deluxe', '2026-10-21', '2026-10-23'),
-                extra('beijing-china-world', 'airport-transfer'),
-                room('shanghai-pudong', 'deluxe-city', '2026-10-19', '2026-10-21'),
-                extra('shanghai-pudong', 'airport-transfer'),
-            ],
-        }, guest, me);
-        expect(made.map((b) => [b.hotelId, b.stay.checkIn, b.stay.checkOut])).toEqual([
-            ['shanghai-pudong', '2026-10-19', '2026-10-21'],
-            ['beijing-china-world', '2026-10-21', '2026-10-23'],
-        ]);
-        expect(new Set(made.map((b) => b.confirmationCode)).size).toBe(2);
-        // Each add-on went with its own hotel's stay.
-        for (const b of made) {
-            expect(b.quote.lines.every((l) => l.hotelId === b.hotelId)).toBe(true);
-            expect(b.quote.lines.filter((l) => l.kind === 'extra')).toHaveLength(1);
-        }
-    });
-    it('books nothing when one stay cannot be held, and says which', async () => {
-        const hotels = make();
-        // Somebody else takes the only Pudong suite.
-        await hotels.requestBooking({ lines: [room('shanghai-pudong', 'suite', '2026-10-21', '2026-10-23')] }, guest, other);
-        await expect(hotels.requestBooking({
-            lines: [
-                room('shanghai-jingan', 'deluxe', '2026-10-19', '2026-10-21'),
-                room('shanghai-pudong', 'suite', '2026-10-21', '2026-10-23'),
-            ],
-        }, guest, me)).rejects.toThrow(/Nothing was booked.*Pudong/);
-        expect(await hotels.listBookings(me)).toEqual([]);
-    });
-    it('refuses an add-on at a hotel the trip has no room at, rather than filing it under another', async () => {
-        await expect(make().requestBooking({
-            lines: [
-                room('shanghai-pudong', 'deluxe-city', '2026-10-19', '2026-10-21'),
-                extra('beijing-kerry', 'kids-club'),
-            ],
-        }, guest, me)).rejects.toThrow(/Nothing was booked.*goes with a stay there/);
-    });
-    // ⚠️ THE TRIP'S OWN LINES COUNT AGAINST EACH OTHER. One suite, two lines for
-    // it on nights that overlap: both used to price, and both were held.
-    it('does not hold the one suite twice for the night two lines share', async () => {
-        const hotels = make();
-        const quote = await hotels.quote({
-            lines: [
-                room('hong-kong-island', 'suite', '2026-10-19', '2026-10-21'),
-                room('hong-kong-island', 'suite', '2026-10-20', '2026-10-22'),
-            ],
-        });
-        expect(quote.lines.filter((l) => l.kind === 'room')).toHaveLength(1);
-        expect(quote.dropped?.[0]?.why).toMatch(/already holds the last/);
-    });
-    it('moves every room type on a booking to the new nights, each keeping its own', async () => {
-        const hotels = make();
-        const [b = none()] = await hotels.requestBooking({
-            lines: [
-                room('hong-kong-kerry', 'deluxe', '2026-10-19', '2026-10-21'),
-                room('hong-kong-kerry', 'family', '2026-10-19', '2026-10-21', 2),
-            ],
-        }, guest, me);
-        const moved = await hotels.changeBooking(b.confirmationCode, { checkOut: '2026-10-22' }, me);
-        const rooms = moved?.quote.lines.filter((l) => l.kind === 'room');
-        expect(rooms?.map((l) => [l.roomRef, l.quantity, l.stay?.checkOut])).toEqual([
-            ['deluxe', 1, '2026-10-22'],
-            ['family', 2, '2026-10-22'],
-        ]);
-        // Changing the room or the count needs a booking of one room type.
-        const pre = await hotels.previewChange(b.confirmationCode, { rooms: 3 }, me);
-        expect(pre?.changeable).toBe(false);
-        expect(pre?.rule).toMatch(/2 room types/);
-    });
-    // ⚠️ THE FIGURE CONFIRMED IS THE FIGURE KEPT. The preview priced the room
-    // alone against the whole booking, add-ons and all.
-    it('previews exactly the total the change then stores', async () => {
-        const hotels = make();
-        const [b = none()] = await hotels.requestBooking({
-            lines: [
-                room('hong-kong-island', 'deluxe-harbour', '2026-10-19', '2026-10-21', 2),
-                extra('hong-kong-island', 'airport-transfer'),
-            ],
-        }, guest, me);
-        const change = { checkIn: '2026-10-23', checkOut: '2026-10-26' };
-        const pre = await hotels.previewChange(b.confirmationCode, change, me);
-        const moved = await hotels.changeBooking(b.confirmationCode, change, me);
-        expect(pre?.to?.total).toEqual(moved?.quote.total);
-        expect(pre?.difference?.minor).toBe((moved?.quote.total.minor ?? 0) - b.quote.total.minor);
-        expect(moved?.quote.lines.filter((l) => l.kind === 'extra')).toHaveLength(1);
-    });
-    it('keeps a per-night add-on at what was asked for when the stay changes', async () => {
-        const withParking = {
-            ...DATA,
-            hotels: DATA.hotels.map((h) => {
-                const [first] = h.extras ?? [];
-                return h.id === 'hong-kong-island' && first
-                    ? {
-                        ...h,
-                        extras: [...(h.extras ?? []), { ...first, id: 'parking', per: 'night' }],
-                    }
-                    : h;
-            }),
-        };
-        const hotels = createDemoHotels({ data: withParking, now: () => clock, rng: () => 0.5 });
-        const [b = none()] = await hotels.requestBooking({
-            lines: [
-                room('hong-kong-island', 'deluxe-city', '2026-10-19', '2026-10-22'),
-                extra('hong-kong-island', 'parking'),
-            ],
-        }, guest, me);
-        const parking = (x) => x?.quote.lines.find((l) => l.extraRef === 'parking')?.quantity;
-        expect(parking(b)).toBe(3);
-        const moved = await hotels.changeBooking(b.confirmationCode, { rooms: 2 }, me);
-        // Three nights, one a night - not the three it came back as, times three.
-        expect(parking(moved)).toBe(3);
-    });
-    it('will not move a booking with any non-refundable room on it', async () => {
-        const hotels = make();
-        const [b = none()] = await hotels.requestBooking({
-            lines: [
-                room('hong-kong-island', 'deluxe-city', '2026-10-19', '2026-10-21'),
-                room('hong-kong-island', 'horizon-club', '2026-10-19', '2026-10-21'),
-            ],
-        }, guest, me);
-        const pre = await hotels.previewChange(b.confirmationCode, { checkOut: '2026-10-22' }, me);
-        expect(pre?.changeable).toBe(false);
-        expect(pre?.rule).toMatch(/non-refundable/);
-    });
-    it('refuses a room name that matches nothing rather than previewing the room already held', async () => {
-        const hotels = make();
-        const [b = none()] = await hotels.requestBooking({ lines: [room('hong-kong-island', 'deluxe-city', '2026-10-19', '2026-10-21')] }, guest, me);
-        const pre = await hotels.previewChange(b.confirmationCode, { room: 'the presidential igloo' }, me);
-        expect(pre?.changeable).toBe(false);
-        expect(pre?.rule).toMatch(/No room type/);
-    });
-});
-// ⚠️ A HOLD TAKES A ROOM ONLY ON ITS OWN NIGHTS (robin, 2026-09-28: 「改成按晚算吧」).
-// It used to take it off every date: one booking in October made the room
-// "not offered" in November, and a few eval runs emptied the Island
-// Shangri-La's deluxe types for every night there is.
-describe('stock is counted by night', () => {
-    const suite = (stay) => ({
-        lines: [{ kind: 'room', hotelId: 'hong-kong-island', roomId: 'suite', stay }],
-    });
-    const other = { sessionId: 'session-b' };
-    const nights = (checkIn, checkOut) => ({ checkIn, checkOut, guests: 3 });
-    const hasSuite = async (hotels, stay) => ((await hotels.getHotel('hong-kong-island', stay))?.rooms ?? []).some((r) => r.id === 'suite');
-    it('leaves another week free', async () => {
-        const hotels = make();
-        await hotels.requestBooking(suite(nights('2026-10-19', '2026-10-21')), guest, me); // the only suite
-        expect(await hasSuite(hotels, nights('2026-10-26', '2026-10-28'))).toBe(true);
-    });
-    it('is gone for a stay that shares even one held night', async () => {
-        const hotels = make();
-        await hotels.requestBooking(suite(nights('2026-10-19', '2026-10-21')), guest, me);
-        expect(await hasSuite(hotels, nights('2026-10-20', '2026-10-22'))).toBe(false);
-        expect(await hasSuite(hotels, nights('2026-10-17', '2026-10-20'))).toBe(false);
-    });
-    it('serves back-to-back stays with one room: checking out is not a night', async () => {
-        const hotels = make();
-        await hotels.requestBooking(suite(nights('2026-10-19', '2026-10-21')), guest, me);
-        expect(await hasSuite(hotels, nights('2026-10-21', '2026-10-23'))).toBe(true);
-        expect(await hasSuite(hotels, nights('2026-10-17', '2026-10-19'))).toBe(true);
-    });
-    it('counts the busiest night of the stay, not the holds added up', async () => {
-        const hotels = make();
-        const harbour = (checkIn, checkOut, rooms) => ({
-            lines: [
-                {
-                    kind: 'room',
-                    hotelId: 'hong-kong-island',
-                    roomId: 'deluxe-harbour', // three in the fixture
-                    rooms,
-                    stay: { checkIn, checkOut, guests: 2 },
-                },
-            ],
-        });
-        await hotels.requestBooking(harbour('2026-10-19', '2026-10-21', 2), guest, me);
-        await hotels.requestBooking(harbour('2026-10-21', '2026-10-23', 1), guest, other);
-        const week = await hotels.getHotel('hong-kong-island', {
-            checkIn: '2026-10-19',
-            checkOut: '2026-10-23',
-            guests: 2,
-        });
-        // Two held on the 19th and 20th, one on the 21st and 22nd: one left for all four.
-        expect(week?.rooms?.find((r) => r.id === 'deluxe-harbour')?.roomsLeft).toBe(1);
-    });
-    it('lets a booking move into nights it partly holds, and keeps its room', async () => {
-        const hotels = make();
-        const [booking = none()] = await hotels.requestBooking(suite(nights('2026-10-19', '2026-10-21')), guest, me);
-        const pre = await hotels.previewChange(booking.confirmationCode, { checkIn: '2026-10-20', checkOut: '2026-10-22' }, me);
-        expect(pre?.changeable, pre?.rule).toBe(true);
-        expect(pre?.roomsLeft).toBe(1);
-        const moved = await hotels.changeBooking(booking.confirmationCode, { checkIn: '2026-10-20', checkOut: '2026-10-22' }, me);
-        // ⚠️ THE RE-QUOTE MUST NOT COUNT THE BOOKING AGAINST ITSELF: it used to drop
-        // the room line whenever stock was tight, and save a booking with no room.
-        expect(moved?.quote.lines.some((l) => l.kind === 'room' && l.roomRef === 'suite')).toBe(true);
-        expect(moved?.stay.checkIn).toBe('2026-10-20');
-        // And now the old first night is free, the new last one is not.
-        expect(await hasSuite(hotels, nights('2026-10-18', '2026-10-20'))).toBe(true);
-        expect(await hasSuite(hotels, nights('2026-10-21', '2026-10-23'))).toBe(false);
-    });
-    it('refuses a move onto nights somebody else holds', async () => {
-        const hotels = make();
-        const [mine = none()] = await hotels.requestBooking(suite(nights('2026-10-19', '2026-10-21')), guest, me);
-        await hotels.requestBooking(suite(nights('2026-10-26', '2026-10-28')), guest, other);
-        const pre = await hotels.previewChange(mine.confirmationCode, { checkIn: '2026-10-26', checkOut: '2026-10-28' }, me);
-        expect(pre?.changeable).toBe(false);
-        await expect(hotels.changeBooking(mine.confirmationCode, { checkIn: '2026-10-26', checkOut: '2026-10-28' }, me)).rejects.toThrow();
-    });
-});
-describe('cancelling', () => {
-    const flexible = {
-        lines: [
-            { kind: 'room', hotelId: 'hong-kong-island', roomId: 'deluxe-city', stay: MON_WED },
-        ],
-    };
-    const nonRefundable = {
-        lines: [
-            { kind: 'room', hotelId: 'hong-kong-island', roomId: 'horizon-club', stay: MON_WED },
-        ],
-    };
-    it('costs nothing inside the free window, and says when that window closes', async () => {
-        const hotels = make();
-        const [booking = none()] = await hotels.requestBooking(flexible, guest, me);
-        const preview = await hotels.previewCancellation(booking.confirmationCode, me);
-        expect(preview?.cancellable).toBe(true);
-        expect(preview?.fee).toEqual({ minor: 0, currency: 'HKD' });
-        expect(preview?.refund).toEqual({ minor: 858_800, currency: 'HKD' });
-        expect(preview?.freeUntil).toBe('2026-10-17T07:00:00.000Z');
-        expect(preview?.rule).toContain('nothing has been charged and nothing will be');
-        // A demonstration has no card and no check-in to put a fee on (2026-10-05 audit, P2).
-        expect(preview?.rule).not.toMatch(/on the card|check-in time/);
-    });
-    it('charges one night plus tax once the window has closed', async () => {
-        clock = Date.parse('2026-10-18T09:00:00Z'); // past 48 hours before arrival
-        const hotels = make();
-        const [booking = none()] = await hotels.requestBooking(flexible, guest, me);
-        const preview = await hotels.previewCancellation(booking.id, me);
-        expect(preview?.fee).toEqual({ minor: 429_400, currency: 'HKD' }); // HK$3,800 + 13%
-        expect(preview?.refund).toEqual({ minor: 429_400, currency: 'HKD' });
-        expect(preview?.rule).toContain('plus tax');
-    });
-    it('charges the whole stay on a non-refundable rate, and says which rate that is', async () => {
-        const hotels = make();
-        const [booking = none()] = await hotels.requestBooking(nonRefundable, guest, me);
-        const preview = await hotels.previewCancellation(booking.confirmationCode, me);
-        expect(preview?.fee).toEqual({ minor: 1_333_400, currency: 'HKD' });
-        expect(preview?.refund).toEqual({ minor: 0, currency: 'HKD' });
-        expect(preview?.rule).toContain('non-refundable');
-    });
-    it('records the fee it previewed, and releases the room', async () => {
-        const hotels = make();
-        const [booking = none()] = await hotels.requestBooking(flexible, guest, me);
-        const preview = await hotels.previewCancellation(booking.id, me);
-        const cancelled = await hotels.cancelBooking(booking.id, me, 'flight moved');
-        expect(cancelled?.status).toBe('cancelled');
-        expect(cancelled?.cancellationFee).toEqual(preview?.fee);
-        expect(cancelled?.guest.notes).toContain('flight moved');
-        expect(await hotels.previewCancellation(booking.id, me)).toMatchObject({ cancellable: false });
-    });
-    it('is nobody else’s business', async () => {
-        const hotels = make();
-        const [booking = none()] = await hotels.requestBooking(flexible, guest, me);
-        const someoneElse = { sessionId: 'session-b' };
-        expect(await hotels.previewCancellation(booking.id, someoneElse)).toBeNull();
-        expect(await hotels.cancelBooking(booking.id, someoneElse)).toBeNull();
-        expect(await hotels.listBookings(someoneElse)).toEqual([]);
-        // ⚠️ NOT BY AN EMAIL ALONE. This test used to say the email was enough to
-        // LIST a stranger's bookings - name, hotel, nights (2026-09-28 audit).
-        expect(await hotels.listBookings({ sessionId: 'session-b', email: guest.email })).toEqual([]);
-        // The code and the email together find the one booking, as a desk would.
-        // The code alone opens nothing elsewhere.
-        expect(await hotels.findBooking(booking.confirmationCode, someoneElse)).toBeNull();
-        // ⚠️ With an email, the CODE and only the code: the id was accepted too,
-        // and it was the time and a counter (2026-09-28 audit).
-        const elsewhere = { sessionId: 'session-b', email: guest.email };
-        expect(await hotels.findBooking(booking.id, elsewhere)).toBeNull();
-        expect((await hotels.findBooking(booking.confirmationCode, elsewhere))?.id).toBe(booking.id);
-        // Found that way it is session-b's too: the code alone opens it there now,
-        // and it is listed there - and still nowhere else.
-        expect((await hotels.findBooking(booking.confirmationCode, someoneElse))?.id).toBe(booking.id);
-        expect((await hotels.listBookings(someoneElse)).map((b) => b.id)).toEqual([booking.id]);
-        expect(await hotels.listBookings({ sessionId: 'session-c' })).toEqual([]);
-    });
-    it('never hands back the conversations a booking belongs to', async () => {
-        const hotels = make();
-        const made = await hotels.requestBooking(flexible, guest, me);
-        const found = await hotels.findBooking(made[0]?.confirmationCode ?? '', me);
-        for (const b of [...made, found, ...(await hotels.listBookings(me))]) {
-            expect(JSON.stringify(b)).not.toContain(me.sessionId);
-            expect(b).not.toHaveProperty('owners');
-            expect(b).not.toHaveProperty('sessionId');
-        }
-    });
-});
-describe('policies', () => {
-    it('gives the hotel its own words, in a fixed order', async () => {
-        const policies = await make().policies('hong-kong-island');
-        expect(policies.map((p) => p.topic)).toEqual([
-            'cancellation',
-            'check-in',
-            'children',
-            'pets',
-            'deposit',
-            'accessibility',
-        ]);
-        expect(policies[0]?.text).toContain('48 hours');
-    });
-    it('answers an unknown hotel with nothing rather than a guess', async () => {
-        expect(await make().policies('hotel-du-nowhere')).toEqual([]);
-    });
-});
-// A guest who can move a day is the commonest way a hotel search gets cheaper,
-// and a night is not a flat rate: the weekend uplift, the tax on what is
-// actually paid and the member's discount all land before the total. Every
-// option on the strip is a real re-quote, so these are the arithmetic guards.
-describe('the dates either side', () => {
-    it('centres the window on the stay and keeps the nights', async () => {
-        const dates = await make().datesAround('hong-kong-island', MON_WED, { rooms: 1, span: 3 }, me);
-        expect(dates.map((d) => d.checkIn)).toEqual([
-            '2026-10-16',
-            '2026-10-17',
-            '2026-10-18',
-            '2026-10-19',
-            '2026-10-20',
-            '2026-10-21',
-            '2026-10-22',
-        ]);
-        // Two nights, every one of them.
-        for (const d of dates) {
-            expect(Date.parse(d.checkOut) - Date.parse(d.checkIn)).toBe(2 * 86_400_000);
-        }
-        expect(dates.filter((d) => d.chosen).map((d) => d.checkIn)).toEqual(['2026-10-19']);
-    });
-    // ⚠️ THE WINDOW IS NOT SLID FORWARD to keep seven chips. A guest arriving
-    // tomorrow gets a short strip, which is the truth; padding it with dates
-    // after the stay would quietly answer a question nobody asked.
-    it('drops arrivals that are already past instead of shifting the window', async () => {
-        const soon = { checkIn: '2026-10-02', checkOut: '2026-10-04', guests: 2 };
-        const dates = await make().datesAround('hong-kong-island', soon, { rooms: 1, span: 3 }, me);
-        // Today where the hotel stands, not four days ago.
-        expect(dates[0]?.checkIn).toBe('2026-10-01');
-        expect(dates.map((d) => d.checkIn)).toHaveLength(5);
-    });
-    it('prices the weekend higher than the weekdays around it', async () => {
-        const dates = await make().datesAround('hong-kong-island', MON_WED, { rooms: 1, span: 3 }, me);
-        const on = (day) => dates.find((d) => d.checkIn === day)?.from?.minor ?? 0;
-        // 2026-10-16 is a Friday: two weekend nights. 2026-10-19 is a Monday: none.
-        expect(on('2026-10-16')).toBeGreaterThan(on('2026-10-19'));
-        expect(on('2026-10-19')).toBe(on('2026-10-20'));
-    });
-    // ⚠️ THE ROOM COUNT IS PART OF THE QUESTION. The cheapest type with one left
-    // is often not the cheapest with three left, so an answer for a party of
-    // three rooms is a different room's price - not one room's times three.
-    it('answers for the rooms asked for, at a type that has that many left', async () => {
-        const hotels = make();
-        const one = await hotels.datesAround('hong-kong-island', MON_WED, { rooms: 1, span: 0 }, me);
-        const three = await hotels.datesAround('hong-kong-island', MON_WED, { rooms: 3, span: 0 }, me);
-        expect(one[0]?.from?.minor).toBeGreaterThan(0);
-        // Whatever the cheapest type with three left is, three of it costs at least
-        // three of the cheapest type with one left.
-        expect(three[0]?.from?.minor).toBeGreaterThanOrEqual((one[0]?.from?.minor ?? 0) * 3);
-    });
-    it('says so rather than omitting a date nothing is left on', async () => {
-        const hotels = make();
-        // The biggest type here has six left, so a party of seven rooms is full
-        // every night of the window - and the window is still seven dates long.
-        const dates = await hotels.datesAround('hong-kong-island', MON_WED, { rooms: 7, span: 3 }, me);
-        expect(dates).toHaveLength(7);
-        expect(dates.every((d) => d.from === undefined)).toBe(true);
-    });
-    it('follows the member rate, because the strip is compared against the room list', async () => {
-        const hotels = make();
-        const member = await hotels.signInMember('SLC-4471-8820', 'Ruan');
-        expect(member).not.toBeNull();
-        const asGuest = await hotels.datesAround('hong-kong-island', MON_WED, { rooms: 1, span: 0 }, me);
-        const asMember = await hotels.datesAround('hong-kong-island', MON_WED, { rooms: 1, span: 0 }, { ...me, member: member ?? undefined });
-        expect(asMember[0]?.from?.minor).toBeLessThan(asGuest[0]?.from?.minor ?? 0);
-    });
-    it('is empty for a hotel that does not exist', async () => {
-        expect(await make().datesAround('atlantis', MON_WED, { rooms: 1, span: 3 }, me)).toEqual([]);
-    });
-    it('does not offer a party of six a date, because no room here sleeps six', async () => {
-        const six = { ...FRI_SUN, guests: 6 };
-        const dates = await make().datesAround('hong-kong-island', six, { rooms: 1, span: 1 }, me);
-        expect(dates.every((d) => d.from === undefined)).toBe(true);
-    });
-});
-// ⚠️ THE SEAM CLEANS THEM TOO. The tool normalises what the model sends, but a
-// merchant importing this package calls the backend directly, and the real
-// hotel API on the other side of it will take whatever is handed over. A code
-// nobody reads is worse than a request nobody made: the guest was told it was
-// asked for.
-describe('the requests a booking carries', () => {
-    const book = async (hotels, requests) => {
-        const trip = {
-            lines: [
-                {
-                    kind: 'room',
-                    hotelId: 'hong-kong-island',
-                    roomId: 'deluxe-city',
-                    stay: MON_WED,
-                },
-            ],
-        };
-        const [b = none()] = await hotels.requestBooking(trip, guest, me, requests);
-        return b;
-    };
-    it('keeps the codes it knows and drops the rest', async () => {
-        const b = await book(make(), {
-            kinds: ['high-floor', 'teleporter', 'high-floor', 'quiet-room'],
-        });
-        expect(b.requests?.kinds).toEqual(['high-floor', 'quiet-room']);
-    });
-    it('cuts the note to a line a desk can read', async () => {
-        const b = await book(make(), { kinds: [], note: `${'a'.repeat(400)}` });
-        expect(b.requests?.note).toHaveLength(200);
-    });
-    it('squashes the whitespace a chat box leaves behind', async () => {
-        const b = await book(make(), { kinds: [], note: '  high   floor\n\nplease  ' });
-        expect(b.requests?.note).toBe('high floor please');
-    });
-    it('refuses an arrival time that is not a time', async () => {
-        const b = await book(make(), { kinds: ['late-arrival'], arrivingAt: '25:99' });
-        expect(b.requests?.arrivingAt).toBeUndefined();
-        expect(b.requests?.kinds).toEqual(['late-arrival']);
-    });
-    it('carries nothing at all when nothing was asked', async () => {
-        expect((await book(make())).requests).toBeUndefined();
-        expect((await book(make(), { kinds: [] })).requests).toBeUndefined();
-    });
-    // A booking that moved is the same booking; the desk was still asked.
-    it('keeps them when the booking is moved to other nights', async () => {
-        const hotels = make();
-        const b = await book(hotels, { kinds: ['high-floor'] });
-        const moved = await hotels.changeBooking(b.confirmationCode, { checkIn: '2026-10-26', checkOut: '2026-10-28' }, me);
-        expect(moved?.requests?.kinds).toEqual(['high-floor']);
-    });
-});
-// ⚠️ A HOTEL QUOTES WHOLE MONEY. The weekend uplift and the member's discount
-// left cents behind - "HK$7,733.72" beside "HK$6,554" on one rate strip read as
-// two kinds of number (2026-09-28 audit). Every hotel, every room, a weekend,
-// with and without a member.
-describe('prices a guest reads', () => {
-    it('are whole amounts of their currency', async () => {
-        const hotels = make();
-        const member = await hotels.signInMember('SLC-4471-8820', 'Ruan');
-        const who = member ? { sessionId: 's', member } : undefined;
-        for (const h of DATA.hotels) {
-            for (const asked of [undefined, who]) {
-                const detail = await hotels.getHotel(h.id, FRI_SUN, asked);
-                for (const r of detail?.rooms ?? []) {
-                    for (const m of [r.nightly, r.stayTotal, r.taxesAndFees, r.publicStayTotal]) {
-                        if (!m)
-                            continue;
-                        expect(m.minor % (m.currency === 'JPY' ? 1 : 100), `${h.id}/${r.id}`).toBe(0);
-                    }
-                }
-            }
-        }
-    });
-});
-//# sourceMappingURL=demo-hotels.test.js.map