@curless/hotel-storefront 0.27.0 → 0.27.1

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

@@ -1,11 +1,13 @@
-import { mkdtempSync, readFileSync } from 'node:fs';
+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, PENDING_WINDOW_MS, Reconciler } from '../huazhu/bookings.js';
+import { BookingStore, LATE_FROM_MS, PENDING_WINDOW_MS, Reconciler, nextCheckAt, } from '../huazhu/bookings.js';
 import { Catalog } from '../huazhu/catalog.js';
-import { HuazhuClient, HuazhuRefusal, HuazhuUnreachable } from '../huazhu/client.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 { createFakeHuazhu, fakeHotel, product } from './__fixtures__/huazhu-fake.js';
@@ -86,6 +88,7 @@ const setup = (opts = {}) => {
         backend,
         dir,
         log,
+        now,
         advance: (ms) => {
             t += ms;
         },
@@ -100,6 +103,13 @@ const room = (hotelId, roomId, stay = STAY, rooms = 1) => ({
     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();
@@ -243,7 +253,9 @@ describe('Huazhu bookings', () => {
             arrivingAt: '22:30',
         });
         expect(b?.status).toBe('confirmed');
-        expect(b?.confirmationCode).toMatch(/^R1001/);
+        // 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);
@@ -277,6 +289,11 @@ describe('Huazhu bookings', () => {
         });
         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();
@@ -291,22 +308,27 @@ describe('Huazhu bookings', () => {
         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(b?.confirmationCode).toMatch(/^R1001/);
+        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 of not-found', async () => {
+    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(/^CUR/);
-        s.advance(PENDING_WINDOW_MS);
-        await s.reconciler.tick();
+        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
@@ -322,11 +344,15 @@ describe('Huazhu bookings', () => {
         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);
-        s.advance(PENDING_WINDOW_MS);
-        await s.reconciler.tick();
-        expect(s.store.get(b?.id ?? '')?.attention).toMatch(/within 24 hours/);
+        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();
@@ -360,7 +386,7 @@ describe('Huazhu bookings', () => {
         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(code)?.status).toBe('HOTEL_CANCEL');
+        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');
     });
@@ -582,10 +608,12 @@ describe('Huazhu at scale, and the paths nothing had run', () => {
         // 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?.confirmationCode).toMatch(/^R1001/);
+        expect(after?.resId).toMatch(/^R1001/);
+        expect(after?.confirmationCode).toBe(b?.confirmationCode);
         expect(after?.pendingSince).toBeUndefined();
         expect(first.fake.bookings.size).toBe(1);
     });
@@ -740,4 +768,472 @@ describe('the window counter behind the booking limits', () => {
         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 flight = s.backend.requestBooking({ lines: [room('1001', 'DR1~BAR')] }, 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);
+    });
+});
 //# sourceMappingURL=huazhu-backend.test.js.map