@curless/hotel-storefront 0.27.5 → 0.27.7

package/dist/__tests__/huazhu-backend.test.js

@@ -1,1326 +0,0 @@
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { createHuazhuHotels } from '../huazhu/backend.js';
-import { BookingStore, LATE_FROM_MS, PENDING_WINDOW_MS, Reconciler, nextCheckAt, } from '../huazhu/bookings.js';
-import { Catalog } from '../huazhu/catalog.js';
-import { HuazhuClient, HuazhuMisconfigured, HuazhuRefusal, HuazhuUnreachable, } from '../huazhu/client.js';
-import { claimStateDir, insecureUrls, originOf } from '../huazhu/origin.js';
-import { offeredAtAll, tagKind } from '../huazhu/sellable.js';
-import { WindowCounter } from '../limits.js';
-import { clientIp } from '../server.js';
-import { shownOf } from '../trip.js';
-import { createFakeHuazhu, fakeHotel, product } from './__fixtures__/huazhu-fake.js';
-// The Huazhu backend driven end to end against a fake of Huazhu's API built
-// from its documentation: the catalog, search, a priced hotel, the date strip,
-// and the booking flow with every way a real booking call can go wrong.
-// 10:00 in Shanghai on 1 October 2026.
-const T0 = Date.parse('2026-10-01T02:00:00Z');
-const STAY = { checkIn: '2026-10-10', checkOut: '2026-10-12', guests: 2 };
-const beijing = fakeHotel('2002', {
-    hotelName: '全季酒店(北京国贸店)',
-    hotelNameEn: 'JI Hotel Beijing Guomao',
-    brandName: '全季',
-    provinceName: '北京市',
-    cityName: '北京市',
-    cityNo: '110100',
-    countyName: '朝阳区',
-    hotelAddressEn: '1 Jianguo Road, Chaoyang District, Beijing',
-    hotelServiceList: [{ childClassCode: 73, childClassName: '游泳池' }],
-    hotelTrafficList: [{ destinationName: '国贸' }],
-});
-const setup = (opts = {}) => {
-    let t = T0;
-    const now = () => t;
-    const dir = opts.dir ?? mkdtempSync(join(tmpdir(), 'huazhu-'));
-    const rates = opts.rates ?? {
-        '1001': [
-            {
-                product: product('DR1', 'BAR', { rateCodeName: '门市价含早' }),
-                price: (d) => (d === '2026-10-11' ? 358 : 328),
-                before: (d) => (d === '2026-10-11' ? 338 : 309),
-                meal: { type: 'BB', count: 1 },
-                cancel: '6PM1D1N_100P',
-            },
-            { product: product('TR1', 'PREPAID'), price: () => 280, guarantee: 'PN' },
-        ],
-        '2002': [{ product: product('DR1', 'BAR2'), price: () => 420, cancel: 'AD0_0' }],
-    };
-    const fake = opts.fake ??
-        createFakeHuazhu({
-            hotels: opts.hotels ?? [fakeHotel('1001'), beijing],
-            rates,
-            now,
-        });
-    const client = new HuazhuClient({
-        baseUrl: 'https://biz.huazhu.test',
-        authUrl: 'https://auth.huazhu.test',
-        credentials: { clientId: 'cid', secret: 'sec', distributorId: 'CURLESS' },
-        fetch: fake.fetch,
-        now,
-    });
-    const log = [];
-    const catalog = new Catalog({ client, stateDir: dir, now, log: (l) => log.push(l) });
-    const store = new BookingStore(dir, now);
-    const reconciler = new Reconciler(store, client, now, (l) => log.push(l));
-    const backend = createHuazhuHotels({
-        brand: 'Huazhu',
-        client,
-        catalog,
-        store,
-        reconciler,
-        paymentType: opts.paymentType ?? 'NGPL',
-        language: 'zh',
-        tz: 'Asia/Shanghai',
-        now,
-        ...(opts.settleWithinMs !== undefined ? { settleWithinMs: opts.settleWithinMs } : {}),
-        ...(opts.limits ? { limits: opts.limits } : {}),
-        sleep: async (ms) => {
-            t += ms;
-        },
-    });
-    // What the tools do before every booking: the guest is shown the trip's
-    // price first (`ShownQuote`). `bookUnseen` is the backend as it is.
-    const bookUnseen = backend.requestBooking.bind(backend);
-    backend.requestBooking = async (trip, g, w, r) => bookUnseen({ ...trip, shown: trip.shown ?? shownOf([await backend.quote({ lines: trip.lines })]) }, g, w, r);
-    return {
-        fake,
-        client,
-        catalog,
-        store,
-        reconciler,
-        backend,
-        bookUnseen,
-        dir,
-        log,
-        now,
-        advance: (ms) => {
-            t += ms;
-        },
-    };
-};
-const who = { sessionId: 'conv-1' };
-const room = (hotelId, roomId, stay = STAY, rooms = 1) => ({
-    kind: 'room',
-    hotelId,
-    roomId,
-    stay,
-    rooms,
-});
-const guest = { name: 'Wei Zhang', email: 'wei@example.com', phone: '13800000000' };
-/** The reconciler's own clock: a tick every five seconds for `ms`. */
-const runWindow = async (s, ms) => {
-    for (let at = 0; at < ms; at += 5_000) {
-        s.advance(5_000);
-        await s.reconciler.tick();
-    }
-};
-describe('Huazhu catalog', () => {
-    it('copies every listed hotel to disk and drops one the list no longer has', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        expect(s.catalog.size).toBe(2);
-        expect(JSON.parse(readFileSync(join(s.dir, 'catalog.json'), 'utf8')).order).toEqual([
-            '1001',
-            '2002',
-        ]);
-        // "将已经终止合作下线的酒店剔除下线": a hotel off the list is off the connector.
-        const again = setup({ dir: s.dir, hotels: [fakeHotel('1001')] });
-        expect(again.catalog.size).toBe(2);
-        await again.catalog.sync();
-        expect(again.catalog.size).toBe(1);
-        expect(again.catalog.get('2002')).toBeUndefined();
-    });
-    it('stops at the daily limit and keeps what it has', async () => {
-        const s = setup();
-        s.fake.fail({ path: '/hotel', kind: 3204, skip: 1 });
-        await s.catalog.sync();
-        expect(s.catalog.size).toBe(1);
-        expect(s.catalog.state().stoppedBecause).toMatch(/daily limit/);
-        expect(s.catalog.stale()).toBe(true);
-    });
-});
-describe('Huazhu search and prices', () => {
-    it('finds a city in Chinese or as the English address spells it, and words anywhere in the record', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        expect((await s.backend.searchHotels({ city: '上海' })).hotels.map((h) => h.id)).toEqual([
-            '1001',
-        ]);
-        expect((await s.backend.searchHotels({ city: '上海市' })).hotels.map((h) => h.id)).toEqual([
-            '1001',
-        ]);
-        expect((await s.backend.searchHotels({ city: 'Beijing' })).hotels.map((h) => h.id)).toEqual([
-            '2002',
-        ]);
-        expect((await s.backend.searchHotels({ query: '国贸' })).hotels.map((h) => h.id)).toEqual([
-            '2002',
-        ]);
-        expect((await s.backend.searchHotels({ filters: { facilities: ['pool'] } })).hotels.map((h) => h.id)).toEqual(['2002']);
-    });
-    it('says out loud which knobs it could not apply', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const noDates = await s.backend.searchHotels({ sort: 'price-low' });
-        expect(noDates.unapplied?.join(' ')).toMatch(/publishes no price without/);
-        const rating = await s.backend.searchHotels({ sort: 'rating' });
-        expect(rating.unapplied?.join(' ')).toMatch(/no guest ratings/);
-    });
-    it('prices every hotel for named nights, and a price order holds', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const r = await s.backend.searchHotels({ stay: STAY, sort: 'price-high' });
-        expect(r.hotels.map((h) => h.id)).toEqual(['2002', '1001']);
-        expect(r.hotels[1]?.forStay?.total).toEqual({ minor: 68_600, currency: 'CNY' });
-        expect(r.unapplied).toBeUndefined();
-    });
-    it('opens a hotel with its sellable rooms, the prepaid rate left out', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const d = await s.backend.getHotel('1001', STAY);
-        expect(d?.hotel.name).toBe('汉庭酒店(上海人民广场1001店)');
-        expect(d?.hotel.imageUrl).toBe('https://ws-p.example.com/f/a.jpg');
-        expect(d?.rooms).toHaveLength(1);
-        const r = d?.rooms?.[0];
-        expect(r).toMatchObject({
-            id: 'DR1~BAR',
-            name: '高级大床房 · 门市价含早',
-            breakfast: true,
-            view: 'Window',
-            sizeSqm: 20,
-            stayTotal: { minor: 68_600, currency: 'CNY' },
-            taxesAndFees: { minor: 3_900, currency: 'CNY' },
-            nights: 2,
-            refundable: true,
-            // 6PM1D1N: free until 18:00 the day before, Shanghai time - and said
-            // on that clock, not as 10:00 UTC.
-            freeCancellationUntil: '2026-10-09T10:00:00.000Z',
-            freeCancellationLocal: 'Fri 9 Oct, 18:00',
-            imageUrl: 'https://ws-p.example.com/f/dr1.jpg',
-        });
-    });
-    it('says why when every rate is prepaid', async () => {
-        const s = setup({
-            rates: { '1001': [{ product: product('DR1', 'PP'), price: () => 300, guarantee: 'PN' }] },
-        });
-        await s.catalog.sync();
-        const d = await s.backend.getHotel('1001', STAY);
-        expect(d?.rooms).toEqual([]);
-        expect(d?.noRooms).toMatch(/paid in advance/);
-    });
-    it('prices the dates either side from one ARI call', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const before = s.fake.calls.filter((c) => c.path === '/ari/daily/offers').length;
-        const opts = await s.backend.datesAround('1001', STAY, { rooms: 1, span: 3 });
-        expect(opts.map((o) => o.checkIn)).toEqual([
-            '2026-10-07',
-            '2026-10-08',
-            '2026-10-09',
-            '2026-10-10',
-            '2026-10-11',
-            '2026-10-12',
-            '2026-10-13',
-        ]);
-        expect(opts.find((o) => o.chosen)?.from).toEqual({ minor: 68_600, currency: 'CNY' });
-        expect(s.fake.calls.filter((c) => c.path === '/ari/daily/offers').length - before).toBe(1);
-    });
-    it('asks for a new token once when Huazhu retires the old one, and carries on', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.retireToken();
-        expect((await s.backend.getHotel('1001', STAY))?.rooms).toHaveLength(1);
-        expect(s.fake.tokens).toBe(2);
-    });
-    it('a 502 from Huazhu is "could not ask", not "no rooms"', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/ari/daily/offers', kind: 'http502', times: 2 });
-        const d = await s.backend.getHotel('1001', STAY);
-        expect(d?.noRooms).toMatch(/could not be asked/);
-    });
-    // One blip failed a whole booking on the sandbox (2026-09-30): the
-    // re-pricing before prebook got "fetch failed" once, and a retry a moment
-    // later would have answered.
-    it('one dropped connection on a read is retried, and nobody hears about it', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/ari/daily/offers', kind: 'unreachable' });
-        expect((await s.backend.getHotel('1001', STAY))?.rooms).toHaveLength(1);
-    });
-});
-describe('Huazhu bookings', () => {
-    it('checks with prebook, then books with the four headers, and keeps it on disk', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const [b] = await s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who, {
-            kinds: ['high-floor', 'late-arrival'],
-            arrivingAt: '22:30',
-        });
-        expect(b?.status).toBe('confirmed');
-        // Our own random code - Huazhu's order number stays inside (P1-6).
-        expect(b?.confirmationCode).toMatch(/^HZ-[A-HJ-NP-Z2-9]{8}$/);
-        expect(s.store.get(b?.id ?? '')?.resId).toMatch(/^R1001/);
-        expect(b?.holdUntil).toBeUndefined();
-        expect(b?.quote.total).toEqual({ minor: 68_600, currency: 'CNY' });
-        const paths = s.fake.calls.map((c) => c.path);
-        expect(paths.indexOf('/reservation/prebook')).toBeLessThan(paths.indexOf('/reservation/book'));
-        const book = s.fake.calls.find((c) => c.path === '/reservation/book');
-        expect(book?.headers).toMatchObject({
-            distributorid: 'CURLESS',
-            authorization: expect.stringMatching(/^Bearer /),
-        });
-        expect(book?.headers.traceid).toBeTruthy();
-        expect(book?.body).toMatchObject({
-            paymentType: 'NGPL',
-            contactPerson: { lastName: 'Zhang', firstName: 'Wei', email: 'wei@example.com' },
-            guestComment: '高楼层，晚到，预计22:30到店',
-            reservations: [
-                {
-                    amountAfterTax: [328, 358],
-                    guaranteePolicyCode: 'PL',
-                    estimatedArrivalTime: '22:30',
-                    adultCount: 2,
-                },
-            ],
-        });
-        expect(String((book?.body).distributorResId)).toMatch(/^CUR/);
-        // Survives a restart: the booking is found by a new process, by code and email.
-        const later = setup({ dir: s.dir });
-        await later.catalog.sync();
-        const found = await later.backend.findBooking(b?.confirmationCode ?? '', {
-            sessionId: 'other',
-            email: 'WEI@example.com',
-        });
-        expect(found?.id).toBe(b?.id);
-        expect(await later.backend.findBooking(b?.confirmationCode ?? '', { sessionId: 'third' })).toBeNull();
-        // ⚠️ Huazhu's sequential order number is no way in, email or not.
-        const resId = s.store.get(b?.id ?? '')?.resId ?? '';
-        expect(await later.backend.findBooking(resId, { sessionId: 'other', email: 'wei@example.com' })).toBeNull();
-        // 0600, like every other state file: names, emails, phone numbers.
-        expect(statSync(join(s.dir, 'bookings.json')).mode & 0o777).toBe(0o600);
-    });
-    it('books nothing when prebook refuses, and says why', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/prebook', kind: 5109 });
-        await expect(s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who)).rejects.toThrow(/Nothing was booked\..*no rooms left/);
-        expect(s.fake.calls.some((c) => c.path === '/reservation/book')).toBe(false);
-    });
-    it('an answer lost on the way back is found by the consistency query', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 'answer-lost' });
-        const [b] = await s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who);
-        expect(b?.status).toBe('confirmed');
-        expect(s.store.get(b?.id ?? '')?.resId).toMatch(/^R1001/);
-        expect(s.fake.calls.filter((c) => c.path === '/reservation/consistency/query').length).toBeGreaterThan(0);
-        // Once, however many times it was asked about.
-        expect(s.fake.bookings.size).toBe(1);
-    });
-    it('a call that never arrived stays "requested" and fails after eight minutes, on a late not-found', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 'unreachable' });
-        const [b] = await s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who);
-        expect(b?.status).toBe('requested');
-        expect(b?.confirmationCode).toMatch(/^HZ-/);
-        // Not a minute early, however the checks fell.
-        const since = s.store.get(b?.id ?? '')?.pendingSince ?? 0;
-        await runWindow(s, since + PENDING_WINDOW_MS - 5_000 - s.now());
-        expect(s.store.get(b?.id ?? '')?.status).toBe('requested');
-        await runWindow(s, 10_000);
-        const after = s.store.get(b?.id ?? '');
-        expect(after?.status).toBe('failed');
-        // The same code it was asked for under (M2).
-        expect(after?.confirmationCode).toBe(b?.confirmationCode);
-        expect(after?.pendingSince).toBeUndefined();
-        expect(after?.attention).toBeUndefined();
-        // ⚠️ /reservation/book IS NEVER RESENT BLIND - not by the client's retry
-        // of calls that got no answer. Whether it exists is the consistency
-        // query's to find out.
-        expect(s.fake.calls.filter((c) => c.path === '/reservation/book')).toHaveLength(1);
-        // At most sixteen queries in the window, as the documentation allows.
-        expect(s.fake.calls.filter((c) => c.path === '/reservation/consistency/query').length).toBeLessThanOrEqual(16);
-    });
-    it('when the follow-up itself cannot get through, a person is asked for', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 'unreachable' });
-        s.fake.fail({ path: '/reservation/consistency/query', kind: 'unreachable', times: 50 });
-        const [b] = await s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who);
-        await runWindow(s, PENDING_WINDOW_MS + 10_000);
-        const after = s.store.get(b?.id ?? '');
-        expect(after?.attention).toMatch(/within 24 hours/);
-        // Unconfirmed - not "failed": nobody knows, and it may be a booking.
-        expect(after?.status).toBe('unconfirmed');
-        expect(s.log.join('\n')).toMatch(/NEEDS A PERSON/);
-        expect(s.backend.health()).toMatchObject({ needsAPerson: 1 });
-        expect((await s.backend.listBookings(who))[0]?.status).toBe('unconfirmed');
-        await expect(s.backend.cancelBooking(b?.confirmationCode ?? '', who)).rejects.toThrow(/a person here is confirming it/);
-    });
-    it('a two-city trip whose second stay is refused takes the first back', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 5210, skip: 1 });
-        const trip = {
-            lines: [
-                room('1001', 'DR1~BAR'),
-                room('2002', 'DR1~BAR2', { checkIn: '2026-10-12', checkOut: '2026-10-14', guests: 2 }),
-            ],
-        };
-        await expect(s.backend.requestBooking(trip, guest, who)).rejects.toThrow(/Nothing was booked.*cancelled again/s);
-        const [first] = [...s.fake.bookings.values()];
-        expect(first?.status).toBe('HOTEL_CANCEL');
-        expect(await s.backend.listBookings(who)).toEqual([
-            expect.objectContaining({ status: 'cancelled', hotelId: '1001' }),
-        ]);
-    });
-    it("previews a cancellation in the rate's own terms, then cancels at Huazhu", async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const [b] = await s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who);
-        const code = b?.confirmationCode ?? '';
-        const p = await s.backend.previewCancellation(code, who);
-        expect(p).toMatchObject({
-            cancellable: true,
-            fee: { minor: 0 },
-            freeUntil: '2026-10-09T10:00:00.000Z',
-        });
-        expect(p?.rule).toMatch(/Free to cancel until 2026-10-09 18:00/);
-        expect(p?.rule).toMatch(/paid at the hotel/);
-        const c = await s.backend.cancelBooking(code, who);
-        expect(c?.status).toBe('cancelled');
-        expect(s.fake.bookings.get(s.store.get(b?.id ?? '')?.resId ?? '')?.status).toBe('HOTEL_CANCEL');
-        // Cancelling twice is an answer, not an error.
-        expect((await s.backend.cancelBooking(code, who))?.status).toBe('cancelled');
-    });
-    it('refuses to move a booking, in words that say what to do instead', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const [b] = await s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who);
-        const p = await s.backend.previewChange(b?.confirmationCode ?? '', { checkIn: '2026-10-11' }, who);
-        expect(p).toMatchObject({ changeable: false });
-        expect(p?.rule).toMatch(/cancel it/);
-    });
-    it('a name too long for Huazhu is refused before anything is sent', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        await expect(s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, { name: 'Wolfeschlegelsteinhausenberger', email: 'a@b.co' }, who)).rejects.toThrow(/16 characters/);
-        expect(s.fake.calls.some((c) => c.path.startsWith('/reservation'))).toBe(false);
-    });
-    it('a system error is retried once with the same distributorResId, as the documentation advises', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 2001 });
-        const [b] = await s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who);
-        expect(b?.status).toBe('confirmed');
-        const ids = s.fake.calls
-            .filter((c) => c.path === '/reservation/book')
-            .map((c) => c.body.distributorResId);
-        expect(ids).toHaveLength(2);
-        expect(new Set(ids).size).toBe(1);
-    });
-    it('says what it cannot do', () => {
-        const s = setup();
-        expect(s.backend.capabilities).toEqual({
-            members: false,
-            extras: false,
-            changes: false,
-            booking: 'pay-at-hotel',
-            policies: false,
-            requiresPhone: true,
-            oneCurrency: true,
-        });
-    });
-});
-describe('Huazhu client', () => {
-    const make = (respond) => {
-        let tokenCalls = 0;
-        const fetch = (async (input) => {
-            const url = String(input);
-            if (url.includes('/oauth/token')) {
-                tokenCalls += 1;
-                await new Promise((r) => setTimeout(r, 5));
-                return new Response(JSON.stringify({ access_token: `t${tokenCalls}`, expires_in: 3600 }), {
-                    status: 200,
-                });
-            }
-            return respond(url);
-        });
-        const client = new HuazhuClient({
-            baseUrl: 'https://biz.test',
-            authUrl: 'https://auth.test',
-            credentials: { clientId: 'a', secret: 'b', distributorId: 'D' },
-            fetch,
-        });
-        return { client, tokenCalls: () => tokenCalls };
-    };
-    const ok = (content) => new Response(JSON.stringify({ code: 1000, content }), { status: 200 });
-    it('fetches ONE token for many calls at once - a second fetch would retire the first', async () => {
-        const m = make(() => ok([]));
-        await Promise.all([m.client.hotels(), m.client.hotels(), m.client.hotels()]);
-        expect(m.tokenCalls()).toBe(1);
-    });
-    // ⚠️ EACH FETCH RETIRES THE TOKEN BEFORE IT. Two calls sent with the same
-    // token, refused a moment apart: the first fetches a new token and retries
-    // with it; the second, refused after that fetch finished, used to fetch
-    // ANOTHER - retiring the first's while its retry was still on the wire, so
-    // the first failed with a token it had been handed a moment before.
-    it('a call refused after the token was already replaced retries with the new one, not a third', async () => {
-        let issued = 0;
-        let current = '';
-        let calls = 0;
-        // A's first try, B's first try, A's retry: B is refused after A's
-        // refresh has finished, and A's retry is still in flight when it is.
-        const delays = [5, 20, 40];
-        const fetch = (async (input, init) => {
-            const url = String(input);
-            if (url.includes('/oauth/token')) {
-                issued += 1;
-                current = `t${issued}`;
-                return new Response(JSON.stringify({ access_token: current, expires_in: 3600 }), {
-                    status: 200,
-                });
-            }
-            const wait = delays[calls++] ?? 5;
-            const auth = new Headers(init?.headers).get('authorization');
-            await new Promise((r) => setTimeout(r, wait));
-            // Checked when the request "arrives" - after its delay.
-            return auth === `Bearer ${current}`
-                ? new Response(JSON.stringify({ code: 1000, content: [] }), { status: 200 })
-                : new Response(JSON.stringify({ code: 2002, message: 'Invalid token' }), { status: 200 });
-        });
-        const client = new HuazhuClient({
-            baseUrl: 'https://biz.test',
-            authUrl: 'https://auth.test',
-            credentials: { clientId: 'a', secret: 'b', distributorId: 'D' },
-            fetch,
-        });
-        // A token, then retired by somebody else before either call lands.
-        await client.tokens.get();
-        current = 'retired-elsewhere';
-        await expect(Promise.all([client.hotels(), client.hotels()])).resolves.toHaveLength(2);
-        expect(issued).toBe(2);
-    });
-    it('a 4xx is an answer, a 5xx or a dropped connection is not', async () => {
-        const four = make(() => new Response(JSON.stringify({ code: 2004, message: 'Required field missing' }), {
-            status: 400,
-        }));
-        await expect(four.client.hotels()).rejects.toBeInstanceOf(HuazhuRefusal);
-        const five = make(() => new Response('bad gateway', { status: 502 }));
-        await expect(five.client.hotels()).rejects.toBeInstanceOf(HuazhuUnreachable);
-        const reset = make(() => {
-            throw new TypeError('fetch failed');
-        });
-        await expect(reset.client.hotels()).rejects.toBeInstanceOf(HuazhuUnreachable);
-        const garbled = make(() => new Response('<html>', { status: 200 }));
-        await expect(garbled.client.hotels()).rejects.toBeInstanceOf(HuazhuUnreachable);
-    });
-    it('a refusal carries the code, the message and the detail', async () => {
-        const m = make(() => new Response(JSON.stringify({
-            code: 5109,
-            message: 'No rooms available for requested dates',
-            responseDes: 'DR1',
-        }), { status: 200 }));
-        await expect(m.client.hotels()).rejects.toMatchObject({ code: 5109, detail: 'DR1' });
-    });
-});
-// The 2026-10-05 review: two costs that grow with Huazhu's list, and four
-// paths nothing exercised.
-describe('Huazhu at scale, and the paths nothing had run', () => {
-    it('writes a long sync down every 500 hotels, not every 50', async () => {
-        const hotels = Array.from({ length: 1200 }, (_, i) => fakeHotel(String(5000 + i)));
-        const s = setup({ hotels, rates: {} });
-        await s.catalog.sync();
-        expect(s.catalog.size).toBe(1200);
-        // The list itself, at 500, at 1000, and the end - not twenty-five times.
-        expect(s.catalog.writes).toBe(4);
-    });
-    it('a sync that missed hotels writes nothing for them and is tried again, not marked whole', async () => {
-        const s = setup();
-        s.fake.fail({ path: '/hotel', kind: 'http502', times: 100 });
-        await s.catalog.sync();
-        expect(s.catalog.size).toBe(0);
-        expect(s.catalog.writes).toBe(1);
-        expect(s.catalog.stale()).toBe(true);
-        expect(s.catalog.state().stoppedBecause).toMatch(/could not be read; they are tried again/);
-    });
-    it('search sees what the list gained, and the hotels’ new date', async () => {
-        const hotels = [fakeHotel('1001')];
-        const s = setup({ hotels });
-        await s.catalog.sync();
-        expect((await s.backend.searchHotels({})).total).toBe(1);
-        hotels.push(fakeHotel('1003'));
-        s.advance(2 * 86_400_000);
-        await s.catalog.sync();
-        const r = await s.backend.searchHotels({});
-        expect(r.total).toBe(2);
-        expect(r.hotels[0]?.todayThere).toBe('2026-10-03');
-    });
-    // Thirty nights and the departure date are thirty-one dates: two ARI calls
-    // of at most thirty, joined in order by mergeOffers.
-    const LONG = { checkIn: '2026-10-10', checkOut: '2026-11-09', guests: 2 };
-    const longRate = (over = {}) => ({
-        '1001': [
-            {
-                product: product('DR1', 'BAR'),
-                price: (d) => (d >= '2026-11-01' ? 400 : 300),
-                cancel: 'AD0_0',
-                ...over,
-            },
-        ],
-    });
-    it('a 30-night stay is priced from two ARI windows, joined in order', async () => {
-        const s = setup({ hotels: [fakeHotel('1001')], rates: longRate() });
-        await s.catalog.sync();
-        const d = await s.backend.getHotel('1001', LONG);
-        // 22 nights at ¥300 (10-10 .. 10-31), 8 at ¥400 (11-01 .. 11-08).
-        expect(d?.rooms?.[0]?.stayTotal).toEqual({
-            minor: (22 * 300 + 8 * 400) * 100,
-            currency: 'CNY',
-        });
-        const asked = s.fake.calls
-            .filter((c) => c.path === '/ari/daily/offers')
-            .map((c) => c.body);
-        expect(asked).toEqual([
-            expect.objectContaining({ startDate: '2026-10-10', endDate: '2026-11-08' }),
-            expect.objectContaining({ startDate: '2026-11-09', endDate: '2026-11-09' }),
-        ]);
-    });
-    it('a rule that sits in the second window still counts - no departure on the 31st date', async () => {
-        const s = setup({
-            hotels: [fakeHotel('1001')],
-            rates: longRate({ restriction: { ctd: (d) => d === '2026-11-09' } }),
-        });
-        await s.catalog.sync();
-        const d = await s.backend.getHotel('1001', LONG);
-        expect(d?.rooms).toEqual([]);
-        expect(d?.noRooms).toMatch(/no departures on 2026-11-09/);
-    });
-    it('rooms left in the second window count too', async () => {
-        const s = setup({
-            hotels: [fakeHotel('1001')],
-            rates: longRate({ inventory: (d) => (d === '2026-11-05' ? 0 : 5) }),
-        });
-        await s.catalog.sync();
-        expect((await s.backend.getHotel('1001', LONG))?.noRooms).toMatch(/taken for those nights/);
-    });
-    it('a booking whose answer was lost as the process died is settled by the next process', async () => {
-        const first = setup({ settleWithinMs: 0 });
-        await first.catalog.sync();
-        first.fake.fail({ path: '/reservation/book', kind: 'answer-lost' });
-        const [b] = await first.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who);
-        // The process "dies" here: the outcome is unknown, and on disk.
-        expect(b?.status).toBe('requested');
-        const second = setup({ dir: first.dir, fake: first.fake });
-        second.advance(5_000);
-        await second.reconciler.tick();
-        const after = second.store.get(b?.id ?? '');
-        expect(after?.status).toBe('confirmed');
-        expect(after?.resId).toMatch(/^R1001/);
-        expect(after?.confirmationCode).toBe(b?.confirmationCode);
-        expect(after?.pendingSince).toBeUndefined();
-        expect(first.fake.bookings.size).toBe(1);
-    });
-    it('a stay that cannot be taken back after its trip failed is named, and flagged for a person', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 5210, skip: 1 });
-        s.fake.fail({ path: '/reservation/cancel', kind: 5401 });
-        const trip = {
-            lines: [
-                room('1001', 'DR1~BAR'),
-                room('2002', 'DR1~BAR2', { checkIn: '2026-10-12', checkOut: '2026-10-14', guests: 2 }),
-            ],
-        };
-        await expect(s.backend.requestBooking(trip, guest, who)).rejects.toThrow(/could not be cancelled automatically and has been flagged/);
-        const stuck = s.store.all().find((r) => r.hotelId === '1001');
-        expect(stuck?.attention).toMatch(/cancel resId R1001\d+ by hand/);
-        expect(s.backend.health()).toMatchObject({ needsAPerson: 1 });
-        expect(s.log.join('\n')).toMatch(/NEEDS A PERSON/);
-    });
-    it('a price that moved before the booking is said with the new price, and nothing is booked', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({
-            path: '/reservation/prebook',
-            kind: 5108,
-            content: {
-                hotelId: '1001',
-                reservationsAri: [{ rates: [{ maxAdultCount: 2, amountAfterTax: [358, 388] }] }],
-            },
-        });
-        await expect(s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who)).rejects.toThrow(/Nothing was booked\. The price of .* changed since it was shown: it is now ¥746 a room for the stay/);
-        expect(s.fake.calls.some((c) => c.path === '/reservation/book')).toBe(false);
-    });
-});
-// The booking limits (robin, 2026-10-05) - see `BookingLimits`. Paid at the
-// hotel and verified by nobody, a booking here is a room a hotel keeps for
-// whoever asked; these are what stop a script from filling hotels with names.
-describe('Huazhu booking limits', () => {
-    /** One night at 1001, `d` days into October - a stay of its own for each booking. */
-    const night = (d) => room('1001', 'DR1~BAR', {
-        checkIn: `2026-10-${String(d).padStart(2, '0')}`,
-        checkOut: `2026-10-${String(d + 1).padStart(2, '0')}`,
-        guests: 2,
-    });
-    const as = (email) => ({ ...guest, email });
-    it('needs a phone number before anything is sent', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        await expect(s.backend.requestBooking({ lines: [night(10)] }, { name: 'Wei Zhang', email: 'w@example.com' }, who)).rejects.toThrow(/phone number/);
-        expect(s.fake.calls.some((c) => c.path.startsWith('/reservation'))).toBe(false);
-    });
-    it('holds one conversation to three bookings still to come', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        for (const [i, d] of [10, 12, 14].entries())
-            await s.backend.requestBooking({ lines: [night(d)] }, as(`g${i}@example.com`), who);
-        await expect(s.backend.requestBooking({ lines: [night(16)] }, as('g9@example.com'), who)).rejects.toThrow(/This conversation already has 3 bookings still to come, and 3 at once is the most/);
-    });
-    it('holds one email to three bookings still to come, across conversations', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        for (const [i, d] of [10, 12, 14].entries())
-            await s.backend.requestBooking({ lines: [night(d)] }, guest, { sessionId: `c${i}` });
-        await expect(s.backend.requestBooking({ lines: [night(16)] }, { ...guest, email: 'WEI@example.com' }, { sessionId: 'c9' })).rejects.toThrow(/already has 3 bookings still to come through this connector/);
-    });
-    it('holds one email to five requests a day - cancelled ones included', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        for (const d of [10, 12, 14, 16, 18]) {
-            const [b] = await s.backend.requestBooking({ lines: [night(d)] }, guest, who);
-            await s.backend.cancelBooking(b?.confirmationCode ?? '', who);
-        }
-        await expect(s.backend.requestBooking({ lines: [night(20)] }, guest, who)).rejects.toThrow(/has asked for 5 bookings in the last 24 hours/);
-        s.advance(25 * 3_600_000);
-        await expect(s.backend.requestBooking({ lines: [night(20)] }, guest, who)).resolves.toHaveLength(1);
-    });
-    it('a request turned away by a limit is not counted against the guest', async () => {
-        const s = setup({ limits: { perEmailPerDay: 2, perConversationLive: 1 } });
-        await s.catalog.sync();
-        await s.backend.requestBooking({ lines: [night(10)] }, guest, { sessionId: 'a' });
-        // Turned away twice by the conversation's limit...
-        for (let i = 0; i < 2; i += 1)
-            await expect(s.backend.requestBooking({ lines: [night(12)] }, guest, { sessionId: 'a' })).rejects.toThrow(/conversation/);
-        // ...and the email has still made one request today, not three: a second
-        // goes through. Counted, the refusals would have used up its day.
-        await expect(s.backend.requestBooking({ lines: [night(12)] }, guest, { sessionId: 'b' })).resolves.toHaveLength(1);
-    });
-    it('holds one network address to its hourly gate, and never asks a request without one', async () => {
-        const s = setup({ limits: { perIpPerHour: 2 } });
-        await s.catalog.sync();
-        for (const [i, d] of [10, 12].entries())
-            await s.backend.requestBooking({ lines: [night(d)] }, as(`n${i}@example.com`), {
-                sessionId: `n${i}`,
-                ip: '203.0.113.7',
-            });
-        await expect(s.backend.requestBooking({ lines: [night(14)] }, as('n9@example.com'), {
-            sessionId: 'n9',
-            ip: '203.0.113.7',
-        })).rejects.toThrow(/from this network in the last hour/);
-        // Another address, or none (a direct connection inside the host), is not held by it.
-        await expect(s.backend.requestBooking({ lines: [night(14)] }, as('m@example.com'), {
-            sessionId: 'm',
-            ip: '198.51.100.1',
-        })).resolves.toHaveLength(1);
-    });
-    it('stops all booking at the deployment’s daily ceiling, and asks for a person', async () => {
-        const s = setup({ limits: { perDeploymentPerDay: 2 } });
-        await s.catalog.sync();
-        for (const [i, d] of [10, 12].entries())
-            await s.backend.requestBooking({ lines: [night(d)] }, as(`d${i}@example.com`), {
-                sessionId: `d${i}`,
-            });
-        await expect(s.backend.requestBooking({ lines: [night(14)] }, as('d9@example.com'), { sessionId: 'd9' })).rejects.toThrow(/paused for now/);
-        expect(s.backend.health()).toMatchObject({ needsAPerson: 1, ceilingHitAt: expect.any(String) });
-        s.advance(25 * 3_600_000);
-        expect(s.backend.health()).toMatchObject({ needsAPerson: 0 });
-    });
-    it('reads the address the edge proxy added, not one the client sent', () => {
-        expect(clientIp('6.6.6.6, 203.0.113.7')).toBe('203.0.113.7');
-        expect(clientIp('203.0.113.7')).toBe('203.0.113.7');
-        expect(clientIp(undefined)).toBeUndefined();
-        expect(clientIp('')).toBeUndefined();
-    });
-});
-describe('the window counter behind the booking limits', () => {
-    it('forgets keys that have left the window before any that are still counting', () => {
-        let t = 0;
-        const c = new WindowCounter(1_000, () => t, 3);
-        c.add('old');
-        t = 2_000; // 'old' has left the window
-        c.add('a');
-        c.add('a');
-        c.add('b');
-        c.add('new'); // four keys, three allowed: 'old' goes, not 'a'
-        expect(c.count('a')).toBe(2);
-        expect(c.count('b')).toBe(1);
-        expect(c.count('new')).toBe(1);
-    });
-    it('when every key is still counting, the one idle longest goes - never the one just counted', () => {
-        let t = 0;
-        const c = new WindowCounter(10_000, () => t, 2);
-        c.add('a');
-        t = 1;
-        c.add('b');
-        t = 2;
-        c.add('a'); // 'a' counted again: 'b' is now the idlest
-        t = 3;
-        c.add('c');
-        expect(c.count('a')).toBe(2);
-        expect(c.count('c')).toBe(1);
-        expect(c.count('b')).toBe(0);
-    });
-});
-// The hotel audit of 2026-10-05, Huazhu's part (docs/audit-2026-10-05-hotels.md,
-// P1 and P3): each as the repro script that found it (e1-e14), against the fake.
-describe('the 2026-10-05 audit: following up a booking call nobody answered', () => {
-    const lostCall = async (consistency) => {
-        const s = setup({ settleWithinMs: 0 });
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 'answer-lost' });
-        if (consistency)
-            s.fake.fail(consistency);
-        const [b] = await s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who);
-        return { s, id: b?.id ?? '', code: b?.confirmationCode ?? '' };
-    };
-    it('e1: a restart nine minutes on asks before it writes off - and finds the booking', async () => {
-        const { s, id } = await lostCall();
-        // Down for nine minutes: no check was ever made.
-        const second = setup({ dir: s.dir, fake: s.fake });
-        second.advance(9 * 60_000);
-        await second.reconciler.tick();
-        const after = second.store.get(id);
-        expect(after?.status).toBe('confirmed');
-        expect(after?.resId).toMatch(/^R1001/);
-    });
-    it('P1-1: "too many requests" and other refusals are not "not found" - unconfirmed, and a person', async () => {
-        const { s, id } = await lostCall({
-            path: '/reservation/consistency/query',
-            kind: 2009,
-            times: 50,
-        });
-        await runWindow(s, PENDING_WINDOW_MS + 10_000);
-        const after = s.store.get(id);
-        expect(after?.status).toBe('unconfirmed');
-        expect(after?.attention).toMatch(/within 24 hours/);
-        // ...and Huazhu has it.
-        expect(s.fake.bookings.size).toBe(1);
-    });
-    it('P1-1: a "not found" only in the first minutes is not enough to write it off', async () => {
-        const { s, id } = await lostCall();
-        // A first, early check that cannot find it yet - then nothing answers.
-        s.fake.fail({ path: '/reservation/consistency/query', kind: 5602 });
-        s.fake.fail({ path: '/reservation/consistency/query', kind: 'unreachable', times: 50 });
-        await runWindow(s, PENDING_WINDOW_MS + 10_000);
-        expect(s.store.get(id)?.status).toBe('unconfirmed');
-    });
-    it('P1-4: the checks reach the end of the window, evenly, and never more than sixteen', () => {
-        const row = { pendingSince: 0 };
-        const at = [];
-        while ((row.checks ?? 0) < 16) {
-            const t = nextCheckAt(row);
-            at.push(t);
-            row.checks = (row.checks ?? 0) + 1;
-            row.checkedAt = t;
-        }
-        expect(at.slice(0, 3)).toEqual([5_000, 12_000, 20_000]);
-        const gaps = at.slice(3).map((t, i) => t - (at[i + 2] ?? 0));
-        expect(Math.max(...gaps) - Math.min(...gaps)).toBeLessThan(1);
-        expect(at.at(-1)).toBeLessThanOrEqual(PENDING_WINDOW_MS);
-        expect(at.at(-1)).toBeGreaterThan(PENDING_WINDOW_MS - 30_000);
-        // Several in the last quarter - where a "not found" means it.
-        expect(at.filter((t) => t >= LATE_FROM_MS).length).toBeGreaterThanOrEqual(3);
-    });
-    it('P1-4: a check that falls behind spreads what is left over the rest of the window', () => {
-        // Last asked 20 s in, the process away until four minutes in.
-        const row = { pendingSince: 0, checks: 3, checkedAt: 240_000 };
-        const next = nextCheckAt(row);
-        expect(next).toBeGreaterThan(240_000);
-        expect(next).toBeLessThan(260_000);
-    });
-});
-describe('the 2026-10-05 audit: what a booking call answered', () => {
-    const booked = async (fail) => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail(fail);
-        const [b] = await s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who);
-        return { s, b, books: s.fake.calls.filter((c) => c.path === '/reservation/book').length };
-    };
-    it('P1-10 / e8: a 200 whose code is a word is not a refusal - the booking is found', async () => {
-        const { s, b, books } = await booked({
-            path: '/reservation/book',
-            kind: 'answer-as',
-            raw: '{"code":"ok","message":"Success"}',
-        });
-        expect(b?.status).toBe('confirmed');
-        expect(books).toBe(1);
-        expect(s.fake.bookings.size).toBe(1);
-    });
-    it('P1-10: a 200 with no code at all is not a refusal either', async () => {
-        const { b, books } = await booked({
-            path: '/reservation/book',
-            kind: 'answer-as',
-            raw: '{"message":"Success"}',
-        });
-        expect(b?.status).toBe('confirmed');
-        expect(books).toBe(1);
-    });
-    it('P1-10: a "yes" with no order number is never booked again', async () => {
-        const { s, b, books } = await booked({
-            path: '/reservation/book',
-            kind: 'answer-as',
-            raw: '{"code":1000,"message":"Success","content":null}',
-        });
-        expect(books).toBe(1);
-        expect(s.fake.bookings.size).toBe(1);
-        expect(b?.status).toBe('confirmed');
-    });
-    it('P1-10: a code /reservation/book does not document is "it may exist", not "nothing was booked"', async () => {
-        const { b } = await booked({ path: '/reservation/book', kind: 9999 });
-        // The fake made nothing; the follow-up says so in eight minutes - until
-        // then it is the guest's booking, waiting.
-        expect(b?.status).toBe('requested');
-    });
-    it('P1-10: a system error twice is "it may exist" too', async () => {
-        const { b, books } = await booked({ path: '/reservation/book', kind: 2001, times: 2 });
-        expect(books).toBe(2);
-        expect(b?.status).toBe('requested');
-    });
-    it('a documented refusal is still "nothing was booked"', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 5210 });
-        await expect(s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who)).rejects.toThrow(/Nothing was booked\..*no rooms left/);
-    });
-});
-describe('the 2026-10-05 audit: one request, one booking', () => {
-    it('P1-2 / e4: the same trip asked for twice at once is booked once, and both get it', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const trip = { lines: [room('1001', 'DR1~BAR')] };
-        const [a, b] = await Promise.all([
-            s.backend.requestBooking(trip, guest, who),
-            s.backend.requestBooking(trip, guest, who),
-        ]);
-        expect(s.fake.bookings.size).toBe(1);
-        expect(a?.[0]?.confirmationCode).toBe(b?.[0]?.confirmationCode);
-    });
-    it('P1-2 / e9: a trip a dead process left half booked is taken back by the next one', async () => {
-        const first = setup();
-        await first.catalog.sync();
-        const trip = {
-            lines: [
-                room('1001', 'DR1~BAR'),
-                room('2002', 'DR1~BAR2', { checkIn: '2026-10-12', checkOut: '2026-10-14', guests: 2 }),
-            ],
-        };
-        await first.backend.requestBooking(trip, guest, who);
-        // Rewritten as it would have been left by a process killed while the
-        // second stay's call was out: the request open, written by that process,
-        // and the second stay's outcome unknown.
-        const path = join(first.dir, 'bookings.json');
-        const file = JSON.parse(readFileSync(path, 'utf8'));
-        for (const it of file.intents)
-            Object.assign(it, { done: undefined, boot: 'a-process-that-died' });
-        const second = file.rows.find((r) => r.hotelId === '2002');
-        Object.assign(second, { status: 'requested', resId: undefined, pendingSince: first.now() });
-        writeFileSync(path, JSON.stringify(file));
-        const next = setup({ dir: first.dir, fake: first.fake });
-        await next.reconciler.tick();
-        // The stay it knows was booked is taken back at once...
-        const at = (hotelId) => [...first.fake.bookings.values()].find((x) => x.request.hotelId === hotelId)?.status;
-        expect(at('1001')).toBe('HOTEL_CANCEL');
-        expect(next.store.orphans()).toEqual([]);
-        // ...and the one whose outcome was unknown, as soon as it turns up.
-        await runWindow(next, 10_000);
-        expect(at('2002')).toBe('HOTEL_CANCEL');
-        // Asked again, the trip is booked afresh - not answered with what was taken back.
-        const again = await next.backend.requestBooking(trip, guest, who);
-        expect(again.map((b) => b.status)).toEqual(['confirmed', 'confirmed']);
-    });
-    it('P1-2: a stopping process starts no booking, and waits for the one in flight', async () => {
-        const s = setup({ settleWithinMs: 0 });
-        await s.catalog.sync();
-        const lines = [room('1001', 'DR1~BAR')];
-        const shown = shownOf([await s.backend.quote({ lines })]);
-        const flight = s.bookUnseen({ lines, shown }, guest, who);
-        const drained = s.backend.drain();
-        await expect(s.backend.requestBooking({ lines: [room('2002', 'DR1~BAR2')] }, guest, { sessionId: 'x' })).rejects.toThrow(/restarting/);
-        await drained;
-        expect((await flight)[0]?.status).toBe('confirmed');
-    });
-    it('P1-5 / e5: the deployment ceiling holds when six guests book at once', async () => {
-        const s = setup({ limits: { perDeploymentPerDay: 2 } });
-        await s.catalog.sync();
-        const results = await Promise.allSettled([10, 12, 14, 16, 18, 20].map((d, i) => s.backend.requestBooking({
-            lines: [
-                room('1001', 'DR1~BAR', {
-                    checkIn: `2026-10-${d}`,
-                    checkOut: `2026-10-${d + 1}`,
-                    guests: 2,
-                }),
-            ],
-        }, { ...guest, email: `p${i}@example.com` }, { sessionId: `p${i}` })));
-        expect(results.filter((r) => r.status === 'fulfilled')).toHaveLength(2);
-        expect(s.fake.bookings.size).toBe(2);
-    });
-    it('P1-5: one email booking five at once from five conversations gets three', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const results = await Promise.allSettled([10, 12, 14, 16, 18].map((d, i) => s.backend.requestBooking({
-            lines: [
-                room('1001', 'DR1~BAR', {
-                    checkIn: `2026-10-${d}`,
-                    checkOut: `2026-10-${d + 1}`,
-                    guests: 2,
-                }),
-            ],
-        }, guest, { sessionId: `q${i}` })));
-        expect(results.filter((r) => r.status === 'fulfilled')).toHaveLength(3);
-    });
-});
-describe('the 2026-10-05 audit: the file every booking is in', () => {
-    it('P1-8 / e11: a file that does not parse stops the connector, and is left as it was', () => {
-        const dir = mkdtempSync(join(tmpdir(), 'huazhu-'));
-        writeFileSync(join(dir, 'bookings.json'), '{"rows":[{"id":"hz_1"');
-        expect(() => new BookingStore(dir)).toThrow(/will not start over it/);
-        expect(readFileSync(join(dir, 'bookings.json'), 'utf8')).toBe('{"rows":[{"id":"hz_1"');
-    });
-    it('P1-8: a file that cannot be read stops it too - only "no file yet" is empty', () => {
-        const dir = mkdtempSync(join(tmpdir(), 'huazhu-'));
-        mkdirSync(join(dir, 'bookings.json'));
-        expect(() => new BookingStore(dir)).toThrow(/could not be read/);
-        expect(new BookingStore(mkdtempSync(join(tmpdir(), 'huazhu-'))).all()).toEqual([]);
-    });
-    it('P1-8: a booking that cannot be written down is not sent', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        // The file's place taken by a directory: every write now fails.
-        mkdirSync(join(s.dir, 'bookings.json'));
-        await expect(s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who)).rejects.toThrow(/could not be written down here .* so it was not asked for/);
-        expect(s.fake.calls.some((c) => c.path === '/reservation/book')).toBe(false);
-        expect(s.backend.health()).toMatchObject({ needsAPerson: 1, writeFailing: expect.any(String) });
-        rmSync(join(s.dir, 'bookings.json'), { recursive: true });
-    });
-});
-describe('the 2026-10-05 audit: what a person is asked to look at', () => {
-    it('P1-9: a resolved booking stops counting, and is forgotten 90 days on', async () => {
-        const s = setup({ settleWithinMs: 0 });
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 'unreachable' });
-        s.fake.fail({ path: '/reservation/consistency/query', kind: 'unreachable', times: 50 });
-        const [b] = await s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who);
-        await runWindow(s, PENDING_WINDOW_MS + 10_000);
-        expect(s.backend.health()).toMatchObject({
-            needsAPerson: 1,
-            attention: [expect.objectContaining({ id: b?.id })],
-        });
-        expect(s.backend.resolve(b?.id ?? '', 'confirmed with Huazhu by phone: never made')).toBeTruthy();
-        expect(s.backend.health()).toMatchObject({ needsAPerson: 0 });
-        // Forgotten 90 days after check-out AND after it was resolved.
-        s.advance(80 * 86_400_000);
-        s.store.update(b?.id ?? '', {});
-        expect(s.store.get(b?.id ?? '')).toBeDefined();
-        s.advance(30 * 86_400_000);
-        s.store.update(b?.id ?? '', {});
-        expect(s.store.get(b?.id ?? '')).toBeUndefined();
-    });
-    it('P1-9: the daily ceiling, once hit, is still known after a restart', async () => {
-        const s = setup({ limits: { perDeploymentPerDay: 1 } });
-        await s.catalog.sync();
-        await s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who);
-        await expect(s.backend.requestBooking({ lines: [room('2002', 'DR1~BAR2')] }, { ...guest, email: 'z@example.com' }, { sessionId: 'z' })).rejects.toThrow(/paused/);
-        const again = setup({ dir: s.dir, fake: s.fake });
-        expect(again.backend.health()).toMatchObject({
-            needsAPerson: 1,
-            ceilingHitAt: expect.any(String),
-        });
-    });
-    it('e13: a take-back Huazhu refuses is flagged once, not tried every thirty seconds forever', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 5210, skip: 1 });
-        s.fake.fail({ path: '/reservation/cancel', kind: 5401, times: 1000 });
-        const trip = {
-            lines: [
-                room('1001', 'DR1~BAR'),
-                room('2002', 'DR1~BAR2', { checkIn: '2026-10-12', checkOut: '2026-10-14', guests: 2 }),
-            ],
-        };
-        await expect(s.backend.requestBooking(trip, guest, who)).rejects.toThrow(/flagged for a person/);
-        const cancels = () => s.fake.calls.filter((c) => c.path === '/reservation/cancel').length;
-        const before = cancels();
-        await runWindow(s, 60 * 60_000);
-        expect(cancels()).toBe(before);
-    });
-    it('e13 / e7: a take-back nobody answered is said as such, tried again further apart, then flagged', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 5210, skip: 1 });
-        s.fake.fail({ path: '/reservation/cancel', kind: 'unreachable', times: 1000 });
-        const trip = {
-            lines: [
-                room('1001', 'DR1~BAR'),
-                room('2002', 'DR1~BAR2', { checkIn: '2026-10-12', checkOut: '2026-10-14', guests: 2 }),
-            ],
-        };
-        await expect(s.backend.requestBooking(trip, guest, who)).rejects.toThrow(/could not be cancelled yet: it is tried again automatically/);
-        const row = s.store.all().find((r) => r.hotelId === '1001');
-        expect(row?.attention).toBeUndefined();
-        await runWindow(s, 6 * 60 * 60_000);
-        // A dropped connection is retried once more by the client: two calls a try.
-        expect(s.fake.calls.filter((c) => c.path === '/reservation/cancel').length).toBe(16);
-        expect(s.store.get(row?.id ?? '')?.attention).toMatch(/cancel resId .* by hand/);
-    });
-    it('a fee for taking a stay back is told to the guest', async () => {
-        const s = setup({
-            rates: {
-                '1001': [{ product: product('DR1', 'BAR'), price: () => 328, cancel: 'AD100P_100P' }],
-                '2002': [{ product: product('DR1', 'BAR2'), price: () => 420, cancel: 'AD0_0' }],
-            },
-        });
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/book', kind: 5210, skip: 1 });
-        const trip = {
-            lines: [
-                room('1001', 'DR1~BAR'),
-                room('2002', 'DR1~BAR2', { checkIn: '2026-10-12', checkOut: '2026-10-14', guests: 2 }),
-            ],
-        };
-        await expect(s.backend.requestBooking(trip, guest, who)).rejects.toThrow(/Cancelling again cost a fee under the rate's terms - .*¥/);
-    });
-});
-describe('the 2026-10-05 audit: which Huazhu answers, and in what words', () => {
-    const clientFor = (fake, sandbox) => new HuazhuClient({
-        baseUrl: 'https://biz.huazhu.test',
-        authUrl: 'https://auth.huazhu.test',
-        credentials: { clientId: 'cid', secret: 'sec', distributorId: 'CURLESS' },
-        fetch: fake.fetch,
-        ...(sandbox ? { sandbox: true } : {}),
-    });
-    const fakeOf = (simulated) => createFakeHuazhu({ hotels: [fakeHotel('1001')], rates: {}, now: () => T0, simulated });
-    it('e12: a live deployment pointed at the simulation stops at the first answer, and stays stopped', async () => {
-        const fake = fakeOf(true);
-        const client = clientFor(fake);
-        await expect(client.hotels()).rejects.toThrow(HuazhuMisconfigured);
-        const calls = fake.calls.length;
-        await expect(client.hotels()).rejects.toThrow(/SIMULATED Huazhu/);
-        expect(fake.calls.length).toBe(calls);
-        expect(client.misconfigured).toMatch(/SIMULATED/);
-    });
-    it('e12: a sandbox deployment pointed at something that is not the simulation stops too', async () => {
-        await expect(clientFor(fakeOf(false), true).hotels()).rejects.toThrow(/may be the real one/);
-        await expect(clientFor(fakeOf(true), true).hotels()).resolves.toHaveLength(1);
-    });
-    it('a token server that is down is "no answer", not a wrong secret', async () => {
-        const client = new HuazhuClient({
-            baseUrl: 'https://biz.test',
-            authUrl: 'https://auth.test',
-            credentials: { clientId: 'a', secret: 'b', distributorId: 'D' },
-            fetch: (async () => new Response('down', { status: 503 })),
-        });
-        await expect(client.hotels()).rejects.toThrow(HuazhuUnreachable);
-    });
-    it('P1-10: digits are a code; a word, a fraction or nothing is no answer at all', async () => {
-        const answering = (body) => new HuazhuClient({
-            baseUrl: 'https://biz.test',
-            authUrl: 'https://auth.test',
-            credentials: { clientId: 'a', secret: 'b', distributorId: 'D' },
-            fetch: (async (input) => String(input).includes('/oauth/token')
-                ? new Response(JSON.stringify({ access_token: 't', expires_in: 3600 }))
-                : new Response(JSON.stringify(body), { status: 200 })),
-        });
-        await expect(answering({ code: '1000', content: [] }).hotels()).resolves.toEqual([]);
-        await expect(answering({ code: '3101' }).hotels()).rejects.toThrow(HuazhuRefusal);
-        for (const bad of [{ code: 'ok' }, { code: 1000.5 }, { message: 'x' }, null, []])
-            await expect(answering(bad).hotels()).rejects.toThrow(HuazhuUnreachable);
-    });
-});
-describe('the 2026-10-05 audit: rate tags', () => {
-    const p = (tags) => product('DR1', 'BAR', { tags });
-    it('P1-11: a tag nobody has read is not sold; a known open one is; allowTags lets a gated one through', () => {
-        const none = new Set();
-        expect(offeredAtAll(p([]), none)).toBe(true);
-        expect(offeredAtAll(p(['Packages', 'FlashSales']), none)).toBe(true);
-        expect(offeredAtAll(p(['StudentDiscount']), none)).toBe(false);
-        expect(offeredAtAll(p(['StudnetDiscount']), none)).toBe(false);
-        expect(offeredAtAll(p(['MidNightBooking']), none)).toBe(false);
-        expect(offeredAtAll(p(['DistrCoupons']), new Set(['DistrCoupons']))).toBe(true);
-        expect(tagKind('Brand2027Promo', none)).toBe('unknown');
-        expect(tagKind('FirstStayDiscount', none)).toBe('gated');
-    });
-});
-describe('the 2026-10-05 audit: whose state directory', () => {
-    const live = originOf({
-        baseUrl: 'https://biz.huazhu.com',
-        authUrl: 'https://auth.huazhu.com',
-        distributorId: 'CURLESS',
-    });
-    const sandboxed = originOf({
-        sandbox: true,
-        baseUrl: 'http://huazhu-sandbox:8791',
-        authUrl: 'http://huazhu-sandbox:8791',
-        distributorId: 'CURLESS',
-    });
-    it('P1-7: a directory is claimed once, and refused to a deployment that is not its own', () => {
-        const dir = mkdtempSync(join(tmpdir(), 'hz-origin-'));
-        claimStateDir(dir, sandboxed);
-        claimStateDir(dir, sandboxed);
-        expect(statSync(join(dir, 'origin.json')).mode & 0o777).toBe(0o600);
-        expect(() => claimStateDir(dir, live)).toThrow(/written by a sandbox deployment/);
-        const other = originOf({
-            ...{ baseUrl: 'https://x', authUrl: 'https://x' },
-            distributorId: 'A',
-        });
-        expect(() => claimStateDir(dir, { ...other, mode: 'sandbox' })).toThrow(/another Huazhu/);
-        // Neither the address nor the account is in the file.
-        expect(readFileSync(join(dir, 'origin.json'), 'utf8')).not.toMatch(/huazhu-sandbox|CURLESS/);
-    });
-    it('P1-7: state from before the mark is the sandbox’s - a sandbox takes it, a live deployment does not', () => {
-        const old = mkdtempSync(join(tmpdir(), 'hz-origin-'));
-        writeFileSync(join(old, 'bookings.json'), '{"rows":[]}');
-        expect(() => claimStateDir(old, live)).toThrow(/can only be the sandbox/);
-        claimStateDir(old, sandboxed);
-        // An empty directory is anybody's first.
-        claimStateDir(mkdtempSync(join(tmpdir(), 'hz-origin-')), live);
-    });
-    it('e12: live is https only', () => {
-        expect(insecureUrls({ baseUrl: 'http://biz', authUrl: 'https://auth' })).toEqual([
-            'http://biz',
-        ]);
-        expect(insecureUrls({ sandbox: true, baseUrl: 'http://sb', authUrl: 'http://sb' })).toEqual([]);
-    });
-});
-describe('the 2026-10-05 audit: the hotel list', () => {
-    it('e14: one empty answer does not take every hotel off the connector', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        expect(s.catalog.size).toBe(2);
-        s.fake.fail({ path: '/hotels', kind: 3101 });
-        s.advance(25 * 3_600_000);
-        await s.catalog.sync();
-        expect(s.catalog.size).toBe(2);
-        expect(s.catalog.stale()).toBe(true);
-        expect(s.log.join('\n')).toMatch(/came back empty/);
-        // The next look, with the list back, is a normal sync.
-        await s.catalog.sync();
-        expect(s.catalog.stale()).toBe(false);
-    });
-});
-describe('the 2026-10-05 audit: what counts against a guest', () => {
-    it('a request Huazhu turned away at prebook is not one of the email’s five a day', async () => {
-        const s = setup({ limits: { perEmailPerDay: 1 } });
-        await s.catalog.sync();
-        s.fake.fail({ path: '/reservation/prebook', kind: 5109 });
-        await expect(s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who)).rejects.toThrow(/no rooms left/);
-        await expect(s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, guest, who)).resolves.toHaveLength(1);
-    });
-});
-describe('a booking asked for from the card (P0-3, 0.27.0)', () => {
-    it('belongs to the card and the conversation both, and the two asking at once book it once', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const trip = { lines: [room('1001', 'DR1~BAR')] };
-        const card = { sessionId: 'card-conn', tripOwner: 'conv-1' };
-        const [a, b] = await Promise.all([
-            s.backend.requestBooking(trip, guest, card),
-            s.backend.requestBooking(trip, guest, who),
-        ]);
-        expect(s.fake.bookings.size).toBe(1);
-        expect(a?.[0]?.confirmationCode).toBe(b?.[0]?.confirmationCode);
-        expect((await s.backend.listBookings(who)).map((x) => x.id)).toEqual([a?.[0]?.id]);
-        expect((await s.backend.listBookings({ sessionId: 'card-conn' })).map((x) => x.id)).toEqual([
-            a?.[0]?.id,
-        ]);
-    });
-    it('refuses a guest field over its limit at the seam, before anything is sent', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        await expect(s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, { ...guest, phone: '1'.repeat(40) }, who)).rejects.toThrow(/phone number of at most 32/);
-        expect(s.fake.calls.some((c) => c.path.startsWith('/reservation'))).toBe(false);
-    });
-});
-describe('the 2026-10-05 audit: the price the guest saw (P1-3)', () => {
-    it('e10: a price that moved since the guest saw it is not booked, and the new one is said', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const lines = [room('1001', 'DR1~BAR')];
-        const shown = shownOf([await s.backend.quote({ lines })]);
-        const [key] = Object.keys(shown.lines);
-        const seen = {
-            ...shown,
-            lines: {
-                [key]: {
-                    ...shown.lines[key],
-                    total: { minor: 65_600, currency: 'CNY' },
-                },
-            },
-        };
-        const err = await s.bookUnseen({ lines, shown: seen }, guest, who).catch((e) => e);
-        expect(err.message).toMatch(/Nothing was booked: .* is now ¥\S+, not the ¥656 shown/);
-        expect(err.code).toBe('price-changed');
-        expect(s.fake.calls.some((c) => c.path.startsWith('/reservation'))).toBe(false);
-    });
-    it('changed cancellation terms are not booked either', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const lines = [room('1001', 'DR1~BAR')];
-        const shown = shownOf([await s.backend.quote({ lines })]);
-        const [key = ''] = Object.keys(shown.lines);
-        const line = shown.lines[key];
-        if (!line)
-            throw new Error('no line was shown');
-        const seen = {
-            ...shown,
-            lines: { [key]: { ...line, freeCancellationUntil: '2026-10-09T15:00:00.000Z' } },
-        };
-        await expect(s.bookUnseen({ lines, shown: seen }, guest, who)).rejects.toThrow(/cancellation terms have changed/);
-    });
-    it('a trip nobody was shown is not booked', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        await expect(s.bookUnseen({ lines: [room('1001', 'DR1~BAR')] }, guest, who)).rejects.toThrow(/has not been shown this trip's price yet/);
-    });
-    it('the price the guest saw is booked', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const lines = [room('1001', 'DR1~BAR')];
-        const shown = shownOf([await s.backend.quote({ lines })]);
-        const [b] = await s.bookUnseen({ lines, shown }, guest, who);
-        expect(b?.status).toBe('confirmed');
-    });
-});
-describe('the 2026-10-05 audit: taxes not given apart', () => {
-    it('a price with no before-tax figure says its taxes are included, not ¥0', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const without = await s.backend.quote({
-            lines: [
-                room('2002', 'DR1~BAR2', { checkIn: '2026-10-12', checkOut: '2026-10-14', guests: 2 }),
-            ],
-        });
-        expect(without.taxesIncluded).toBe(true);
-        const split = await s.backend.quote({ lines: [room('1001', 'DR1~BAR')] });
-        expect(split.taxesIncluded).toBeUndefined();
-        expect(split.taxesAndFees.minor).toBeGreaterThan(0);
-    });
-});
-describe('the 2026-10-05 audit: how far ahead Huazhu sells', () => {
-    it('a stay past sellDays is said to be not on sale yet, and Huazhu is not asked for its prices', async () => {
-        const s = setup();
-        await s.catalog.sync();
-        const far = { checkIn: '2027-01-05', checkOut: '2027-01-07', guests: 2 };
-        const d = await s.backend.getHotel('1001', far);
-        expect(d?.rooms).toEqual([]);
-        expect(d?.noRooms).toMatch(/Not on sale yet: rooms here are on sale at most 90 days ahead/);
-        expect(s.fake.calls.some((c) => c.path === '/ari/daily/offers')).toBe(false);
-        // Inside it, priced as ever.
-        expect((await s.backend.getHotel('1001', STAY))?.rooms?.length).toBeGreaterThan(0);
-    });
-});
-//# sourceMappingURL=huazhu-backend.test.js.map