@medalsocial/booking 0.0.0-placeholder.0 → 0.2.0

package/dist/next/seed.mjs

@@ -0,0 +1,495 @@
+import { normaliseCategory } from "../core/categories.mjs";
+import { createClock } from "../core/clock.mjs";
+import { serviceMatches } from "../core/deep-link.mjs";
+import { createDto, toBookingDayDto, toBookingSlotDto } from "../core/dto.mjs";
+import { firstOpeningPerResource } from "../core/next-available.mjs";
+import { inBackground, timed } from "./options.mjs";
+//#region src/next/seed.ts
+/**
+* The booking seed: everything the first two steps of the booking page need,
+* from the edge (L1) cache.
+*
+* WHY. Every read through `catalogue.ts` goes through the data cache, which on
+* OpenNext is the regional Cache API in front of R2 plus a Durable Object round
+* trip for the tag check — 0.25–0.5 s per read even when warm, and the page
+* needed two or three rounds of them. A Workers Cache API read
+* (`caches.default`) is a few milliseconds.
+*
+* WHAT. Two edge entries, read in sequence:
+*
+* - the CATALOGUE — `{ services, resources }` — shared by every prefetch set,
+*   one-minute key bucket;
+* - the SEED for one prefetch set — `{ slots, schedules }` per service over
+*   the page's window — 30-second key bucket.
+*
+* Assembled, `loadBookingSeed` answers `{ services, resources, nextAvailable,
+* schedules, slots, generatedAt }`. The GUARDIAN (cookie-dependent) never goes
+* in; the page reads it on its own.
+*
+* A MISS builds from the `catalogue.ts` loaders, in parallel, so the rounding,
+* the 62-day bypass and every other bound there still applies — the edge entry
+* is one more layer in front, not a second way to ask Medal. An entry is only
+* stored when every part of it was read; a failure is served to this request
+* (absent from the seed, fetched on demand by the wizard) and is not pinned for
+* the next visitor.
+*
+* A HIT is re-filtered to now: an entry up to 30 s old may hold a slot that has
+* since started, and «next free» is derived after that filter.
+*
+* KEYS. `<edgePrefix>/<env>[-<version>]/…`, mapped onto storage keys by the
+* edge adapter (the Workers adapter puts the site's origin in front, because
+* Cache API entries belong to the zone). The environment is in the path
+* because staging and production can share a zone. The seed key holds the
+* local day (the window ends on a local midnight), the SORTED prefetch ids and
+* the 30 s bucket. The prefetch ids are always the output of `prefetchTargets`
+* over the catalogue — a deep link that names no bookable service falls back
+* to the default set — so the number of distinct keys per bucket is at most
+* one per bookable service plus one.
+*
+* STALENESS. A seed is at most 30 s older than the slot entry it was built
+* from, which `catalogue.ts` bounds at ~60 s: ~90 s for a booking made
+* anywhere else. The site's own create / move / cancel (and a SLOT_TAKEN)
+* delete every seed key containing an affected service in this location
+* (`expireBookingSeeds`), and first write a per-service expiry marker (plus
+* one location-wide marker, so a hit checks one key, not one per service) so
+* a build already in flight when the write landed does not store its
+* pre-write seed (it still serves it to its own request), and a hit built
+* before the write is not served; in OTHER locations such a seed
+* stays until its bucket turns, ≤30 s. Medal re-checks every slot at submit,
+* and the 409 already carries fresh openings, so a stale seed costs a retry,
+* never a double booking.
+*/
+const SEED_BUCKET_MS = 3e4;
+const SEED_TTL_S = 30;
+const CATALOGUE_BUCKET_MS = 6e4;
+const CATALOGUE_TTL_S = 60;
+/**
+* STALE-WHILE-REVALIDATE. The bucketed keys above keep a location warm only
+* while visitors keep coming; after a quiet minute the first visitor there
+* paid a full rebuild. So each build is ALSO kept under a «latest» key without
+* the bucket, and a bucket miss serves it at once while one rebuild runs
+* behind the response:
+*
+* - the catalogue (services, stylists) for up to `CATALOGUE_STALE_MAX_S`;
+* - a seed for up to `SEED_STALE_MAX_MS`, and ONLY when no create / move /
+*   cancel handled IN THIS LOCATION has touched its services since it was
+*   built (the expiry markers, kept at least that long, and awaited by the
+*   write routes before they answer). The markers are per location: a booking
+*   handled elsewhere, or made outside this site, can show as open here for at
+*   most `SEED_STALE_MAX_MS` — Medal answers that slot at submit with a 409
+*   carrying fresh openings.
+*
+* One refresh per key at a time in an isolate (`once`), and a refresh never
+* replaces a kept copy built later than its own (`isNewer`), so a burst of
+* visitors to a quiet location costs one rebuild and out-of-order finishes
+* cannot put older openings back.
+*/
+const CATALOGUE_STALE_MAX_S = 3600;
+const SEED_STALE_MAX_MS = 3e5;
+/**
+* The per-service expiry marker: the instant this location last saw a write
+* to the service (`expireBookingSeeds`). Outlives any seed build and any
+* «latest» seed that could still be served stale (`SEED_STALE_MAX_MS`).
+*/
+const MARKER_TTL_S = 600;
+/**
+* The location-wide marker (`anyExpiryMarkerKey`) is the instant of the last
+* write to ANY service here, so a hit reads one key instead of one per
+* prefetched service (up to `window.prefetchLimit`). Only when it is at or
+* within this margin of a seed's build instant are the per-service markers
+* read, to tell a write to one of the seed's services from a write to another
+* one. The margin covers writes racing: the edge has no compare-and-set, so
+* the location-wide marker can end on an earlier write whose put landed after
+* a later one's; the per-service markers still hold the later. One seed
+* bucket: far longer than an edge put takes, and a hit within it of a write
+* costs the per-service reads it always cost before.
+*
+* When the location-wide marker cannot be read, or the adapter cannot store
+* it, the per-service markers are read instead. When it is simply absent (no
+* write here within `MARKER_TTL_S`, or its put failed while a per-service put
+* succeeded) the hit is served; as with any marker that failed, the
+* background deletes and the 30 s bucket still bound that seed.
+*/
+const MARKER_RACE_MS = SEED_BUCKET_MS;
+/**
+* How long after the first delete the second one runs. The first can land
+* BEFORE the write it answers is visible to a concurrent seed build: the slot
+* tag expiry is written in the platform's deferred work, and a booking-page
+* miss already in flight puts the seed it built from pre-booking slots once it
+* is done. Either puts a stale seed back after the first delete; the second
+* pass removes it. A build that starts after the tag expiry has landed reads
+* live.
+*/
+const SEED_RECHECK_MS = 2e3;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function createSeed(options, catalogue) {
+	const { config, logger } = options;
+	const { edge } = options.cache;
+	const SEED_PATH = options.cache.edgePrefix ?? "/__medal-edge/booking-seed/v1";
+	const RANGE_DAYS = config.window.rangeDays;
+	const PREFETCH_LIMIT = config.window.prefetchLimit;
+	const clock = createClock(config);
+	const { toBookingServiceDto, toBookingResourceDto } = createDto(config);
+	/** In-flight refreshes by edge key, shared by every request in this isolate. */
+	const inflight = /* @__PURE__ */ new Map();
+	function once(key, work) {
+		const running = inflight.get(key);
+		if (running) return running;
+		const started = work().finally(() => inflight.delete(key));
+		inflight.set(key, started);
+		return started;
+	}
+	/** A package key as the adapter stores it, or `null` when it cannot store now. */
+	function storageKey(key) {
+		return edge.key ? edge.key(key) : key;
+	}
+	function keyBase() {
+		const env = options.cache.environment || "unknown";
+		const version = edge.version?.();
+		const base = `${SEED_PATH}/${encodeURIComponent(version ? `${env}-${version}` : env)}`;
+		return storageKey(base) === null ? null : base;
+	}
+	function keyed(path) {
+		const base = keyBase();
+		return base === null ? null : storageKey(path(base));
+	}
+	/**
+	* The services worth prefetching, in order, capped at `PREFETCH_LIMIT`: the
+	* one the link names (it is the one the visitor is known to want), then the
+	* bookable `window.prefetchCategory` menu. An unknown value is ignored.
+	*/
+	function prefetchTargets(services, named) {
+		const linked = named ? services.find((service) => service.bookableOnline && serviceMatches(service, named)) : void 0;
+		const prefetchCategory = config.window.prefetchCategory;
+		const kids = prefetchCategory === null ? [] : services.filter((service) => service.bookableOnline && normaliseCategory(config, service.category) === prefetchCategory && service.id !== linked?.id);
+		return [...linked ? [linked] : [], ...kids].slice(0, PREFETCH_LIMIT);
+	}
+	/** The ids a seed is keyed by: sorted, so the order of the set is not a key. */
+	function prefetchKey(targets) {
+		return [...new Set(targets.map((target) => target.id))].sort().map(encodeURIComponent).join(",");
+	}
+	function seedBucket(now) {
+		return Math.floor(now / SEED_BUCKET_MS);
+	}
+	function expiryMarkerKey(serviceId) {
+		return keyed((base) => `${base}/gen/${encodeURIComponent(serviceId)}`);
+	}
+	/** The location-wide expiry marker: the last write to any service here. */
+	function anyExpiryMarkerKey() {
+		return keyed((base) => `${base}/gen-any`);
+	}
+	function catalogueKeyAt(now) {
+		return keyed((base) => `${base}/catalogue/${Math.floor(now / CATALOGUE_BUCKET_MS)}`);
+	}
+	/** The catalogue kept past its bucket, for a stale-while-revalidate serve. */
+	function catalogueLatestKey() {
+		return keyed((base) => `${base}/catalogue/latest`);
+	}
+	/** One prefetch set's seed kept past its bucket, for the same local day. */
+	function seedLatestKeyAt(key, now) {
+		if (key === "") return null;
+		return keyed((base) => `${base}/seed-latest/${clock.dayKey(now)}/${key}`);
+	}
+	/** The seed key for one prefetch set at one instant. */
+	function seedKeyAt(key, now) {
+		if (key === "") return null;
+		return keyed((base) => `${base}/seed/${clock.dayKey(now)}/${key}/${seedBucket(now)}`);
+	}
+	async function edgeRead(key) {
+		try {
+			return await edge.get(key);
+		} catch (error) {
+			logger.warn({ err: error }, "Could not read the booking seed from the colo cache");
+			return;
+		}
+	}
+	function edgeWrite(key, value, ttlSeconds) {
+		return inBackground(edge, edge.put(key, value, ttlSeconds));
+	}
+	/** Whether a copy built at `builtAt` may replace what `key` holds now. */
+	async function isNewer(key, builtAt) {
+		const kept = await edgeRead(key);
+		const keptAt = kept?.generatedAt ?? kept?.builtAt;
+		return typeof keptAt !== "number" || builtAt >= keptAt;
+	}
+	/**
+	* One expiry marker, `null` when it is not set, or `failed` when the
+	* adapter cannot store it or the read fails.
+	*/
+	async function readMarker(key, failed) {
+		if (key === null) return failed;
+		try {
+			const hit = await edge.get(key);
+			const mark = hit === void 0 ? NaN : Number(hit);
+			return Number.isFinite(mark) ? mark : null;
+		} catch {
+			return failed;
+		}
+	}
+	/**
+	* The latest per-service expiry marker among `targets`, or `null`. A marker
+	* that cannot be read counts as none: the delete passes and the 30 s bucket
+	* still bound it.
+	*/
+	async function latestExpiry(targets) {
+		const valid = (await Promise.all(targets.map(({ id }) => readMarker(expiryMarkerKey(id), null)))).filter((mark) => mark !== null);
+		return valid.length === 0 ? null : Math.max(...valid);
+	}
+	/**
+	* Whether a write touching one of `targets`' services was marked at or
+	* after an instant — i.e. a seed built then may hold pre-write openings.
+	* The location-wide marker is read once, as soon as this is called (so it
+	* runs alongside the seed read); the per-service markers only when it does
+	* not rule a write out (`MARKER_RACE_MS`), and then once for every check.
+	*/
+	function expiryCheck(targets) {
+		const any = readMarker(anyExpiryMarkerKey(), "unknown");
+		let perService;
+		return async (since) => {
+			const anyAt = await any;
+			if (anyAt === null || anyAt !== "unknown" && anyAt < since - MARKER_RACE_MS) return false;
+			perService ??= latestExpiry(targets);
+			const latest = await perService;
+			return latest !== null && latest >= since;
+		};
+	}
+	async function writeExpiryMarkers(serviceIds, at) {
+		const keys = [...serviceIds.map(expiryMarkerKey), anyExpiryMarkerKey()];
+		await Promise.all(keys.map(async (key) => {
+			if (key === null) return;
+			try {
+				await edge.put(key, at, MARKER_TTL_S);
+			} catch (error) {
+				logger.warn({ err: error }, "Could not mark booking seeds expired");
+			}
+		}));
+	}
+	/** The catalogue straight from `catalogue.ts`. Services failing throws. */
+	async function readCatalogue() {
+		const [services, resources] = await Promise.all([catalogue.cachedServices(), catalogue.cachedResources().then((list) => list.map(toBookingResourceDto), (error) => {
+			logger.warn({ err: error }, "Could not prefetch the stylists for the booking page");
+			return null;
+		})]);
+		return {
+			catalogue: {
+				services: services.map(toBookingServiceDto),
+				resources
+			},
+			complete: resources !== null
+		};
+	}
+	/**
+	* The catalogue, from the edge when there is one. Throws when the services
+	* cannot be read — the one failure that replaces the wizard.
+	*/
+	async function loadBookingCatalogue(now = Date.now()) {
+		return timed(options.timing, "catalogue", async () => {
+			const key = catalogueKeyAt(now);
+			if (key === null) return (await readCatalogue()).catalogue;
+			const hit = await edgeRead(key);
+			if (hit && Array.isArray(hit.services)) return hit;
+			const refresh = () => once(`${key}#refresh`, async () => {
+				const builtAt = Date.now();
+				const { catalogue: built, complete } = await readCatalogue();
+				if (complete && built.services.length > 0) {
+					await edgeWrite(key, built, CATALOGUE_TTL_S);
+					const latest = catalogueLatestKey();
+					if (latest !== null && await isNewer(latest, builtAt)) await edgeWrite(latest, {
+						...built,
+						builtAt
+					}, CATALOGUE_STALE_MAX_S);
+				}
+				return built;
+			});
+			const latest = catalogueLatestKey();
+			const stale = latest === null ? void 0 : await edgeRead(latest);
+			if (stale && Array.isArray(stale.services) && stale.services.length > 0) {
+				inBackground(edge, refresh().catch((error) => {
+					logger.warn({ err: error }, "Could not refresh the booking catalogue");
+				}));
+				return stale;
+			}
+			return refresh();
+		});
+	}
+	/** One read per service, best effort per service. */
+	async function prefetchEach(targets, what, readOne) {
+		const entries = (await Promise.all(targets.map(async (service) => {
+			try {
+				return [service.id, await readOne(service.id)];
+			} catch (error) {
+				logger.warn({
+					err: error,
+					serviceId: service.id
+				}, `Could not prefetch ${what}`);
+				return null;
+			}
+		}))).filter((entry) => entry !== null);
+		return {
+			values: Object.fromEntries(entries),
+			complete: entries.length === targets.length
+		};
+	}
+	async function buildSeed(targets, fromTs, toTs) {
+		const [slots, schedules] = await Promise.all([prefetchEach(targets, "availability", async (serviceId) => (await catalogue.cachedAvailability({
+			serviceId,
+			fromTs,
+			toTs
+		})).flatMap(toBookingSlotDto)), prefetchEach(targets, "the schedule", async (serviceId) => (await catalogue.cachedSchedule({
+			serviceId,
+			fromTs,
+			toTs
+		})).flatMap(toBookingDayDto))]);
+		return {
+			seed: {
+				slots: slots.values,
+				schedules: schedules.values,
+				generatedAt: fromTs
+			},
+			complete: slots.complete && schedules.complete
+		};
+	}
+	/** A stored seed as of `now`: slots that have started since it was built go. */
+	function freshen(seed, now, toTs) {
+		const slots = Object.fromEntries(Object.entries(seed.slots).map(([serviceId, list]) => [serviceId, list.filter((slot) => slot.startTs >= now && slot.startTs < toTs)]));
+		return {
+			...seed,
+			slots
+		};
+	}
+	/**
+	* The seed for the page: the catalogue plus openings and hours for the
+	* prefetch set `named` selects. Throws only when the catalogue cannot be read.
+	*
+	* The state (hit / stale / miss / bypass) goes to the timing sink with the
+	* seed phase, for `x-booking-seed`.
+	*/
+	async function loadBookingSeed(named, now = Date.now()) {
+		const loaded = await loadBookingCatalogue(now);
+		const { toTs } = clock.window(now, RANGE_DAYS);
+		const targets = prefetchTargets(loaded.services, named);
+		let state = "miss";
+		const markSeed = (next) => {
+			state = next;
+		};
+		const stored = await timed(options.timing, "seed", async () => {
+			const key = seedKeyAt(prefetchKey(targets), now);
+			if (key === null) {
+				markSeed("bypass");
+				return (await buildSeed(targets, now, toTs)).seed;
+			}
+			const expired = expiryCheck(targets);
+			const hit = await edgeRead(key);
+			if (hit?.slots && hit.schedules && !await expired(hit.generatedAt)) {
+				markSeed("hit");
+				return freshen(hit, now, toTs);
+			}
+			const latestKey = seedLatestKeyAt(prefetchKey(targets), now);
+			const rebuild = () => once(`${key}#rebuild`, async () => {
+				const buildStart = Date.now();
+				const { seed, complete } = await buildSeed(targets, now, toTs);
+				if (complete && !await expiryCheck(targets)(buildStart)) {
+					await edgeWrite(key, seed, SEED_TTL_S);
+					if (latestKey !== null && await isNewer(latestKey, seed.generatedAt)) await edgeWrite(latestKey, seed, Math.ceil(SEED_STALE_MAX_MS / 1e3));
+				}
+				return seed;
+			});
+			const stale = latestKey === null ? void 0 : await edgeRead(latestKey);
+			if (stale?.slots && stale.schedules && now - stale.generatedAt < 3e5 && !await expired(stale.generatedAt)) {
+				markSeed("stale");
+				inBackground(edge, rebuild().catch((error) => {
+					logger.warn({ err: error }, "Could not refresh the booking seed");
+				}));
+				return freshen(stale, now, toTs);
+			}
+			markSeed("miss");
+			return rebuild();
+		}, () => ({ state }));
+		const nextAvailable = loaded.resources === null ? {} : Object.fromEntries(Object.entries(stored.slots).map(([serviceId, slots]) => [serviceId, firstOpeningPerResource(slots)]));
+		return {
+			...loaded,
+			slots: stored.slots,
+			schedules: stored.schedules,
+			nextAvailable,
+			generatedAt: stored.generatedAt,
+			fromTs: now,
+			toTs
+		};
+	}
+	/**
+	* Every prefetch set the page can key a seed by: the default one and one per
+	* bookable service a deep link can name. Deterministic from the catalogue.
+	*/
+	function allPrefetchKeys(services) {
+		const sets = [prefetchTargets(services, void 0), ...services.filter((service) => service.bookableOnline).map((service) => prefetchTargets(services, service.id))];
+		return [...new Set(sets.filter((set) => set.length > 0).map(prefetchKey))];
+	}
+	/**
+	* The edge keys to delete after a write touching `serviceIds`: every prefetch
+	* set containing one of them, in the current and the previous 30 s bucket (a
+	* seed from the previous bucket can still be read by a request that started
+	* in it). Sets not containing an affected service are left alone.
+	*/
+	function seedKeysFor(services, serviceIds, now) {
+		const affected = new Set(serviceIds);
+		if (affected.size === 0) return [];
+		const keys = allPrefetchKeys(services).filter((key) => key.split(",").some((id) => affected.has(decodeURIComponent(id))));
+		const instants = [now, now - SEED_BUCKET_MS];
+		return [...new Set(keys.flatMap((key) => [...instants.map((at) => seedKeyAt(key, at)), seedLatestKeyAt(key, now)]).filter((k) => k !== null))];
+	}
+	async function deleteSeeds(serviceIds, now) {
+		const current = catalogueKeyAt(now);
+		const previous = catalogueKeyAt(now - CATALOGUE_BUCKET_MS);
+		if (current === null || previous === null) return;
+		const kept = await edgeRead(current) ?? await edgeRead(previous);
+		const services = Array.isArray(kept?.services) ? kept.services : (await catalogue.cachedServices()).map(toBookingServiceDto);
+		await edge.delete(seedKeysFor(services, serviceIds, now));
+	}
+	/**
+	* Mark `serviceIds` expired (so an in-flight build started before now does
+	* not store its seed), then delete this location's seeds containing any of
+	* them, after a create / move / cancel or a SLOT_TAKEN — twice, the second
+	* time `recheckAfterMs` later (see `SEED_RECHECK_MS`). The deletes run on the
+	* adapter's `defer`, so they add nothing to the response; best effort — the
+	* write has already happened and the 30 s bucket is the backstop. A no-op
+	* when the edge adapter cannot store anything.
+	*/
+	function expireBookingSeeds(serviceIds, now = Date.now(), recheckAfterMs = SEED_RECHECK_MS) {
+		const ids = [...new Set(serviceIds)];
+		if (ids.length === 0 || keyBase() === null) return Promise.resolve();
+		const pass = (at) => deleteSeeds(ids, at).catch((error) => {
+			logger.warn({ err: error }, "Could not expire booking seeds");
+		});
+		const marked = writeExpiryMarkers(ids, now);
+		inBackground(edge, (async () => {
+			await marked;
+			await pass(now);
+			await sleep(recheckAfterMs);
+			await pass(now + recheckAfterMs);
+		})());
+		return marked;
+	}
+	return {
+		RANGE_DAYS,
+		PREFETCH_LIMIT,
+		prefetchTargets,
+		prefetchKey,
+		seedBucket,
+		expiryMarkerKey,
+		anyExpiryMarkerKey,
+		catalogueKeyAt,
+		catalogueLatestKey,
+		seedLatestKeyAt,
+		seedKeyAt,
+		loadBookingCatalogue,
+		loadBookingSeed,
+		allPrefetchKeys,
+		seedKeysFor,
+		expireBookingSeeds,
+		resetSeedRefreshes: () => inflight.clear()
+	};
+}
+//#endregion
+export { SEED_RECHECK_MS, SEED_STALE_MAX_MS, createSeed };
+
+//# sourceMappingURL=seed.mjs.map

package/dist/next/seed.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.mjs","names":[],"sources":["../../src/next/seed.ts"],"sourcesContent":["/**\n * The booking seed: everything the first two steps of the booking page need,\n * from the edge (L1) cache.\n *\n * WHY. Every read through `catalogue.ts` goes through the data cache, which on\n * OpenNext is the regional Cache API in front of R2 plus a Durable Object round\n * trip for the tag check — 0.25–0.5 s per read even when warm, and the page\n * needed two or three rounds of them. A Workers Cache API read\n * (`caches.default`) is a few milliseconds.\n *\n * WHAT. Two edge entries, read in sequence:\n *\n * - the CATALOGUE — `{ services, resources }` — shared by every prefetch set,\n *   one-minute key bucket;\n * - the SEED for one prefetch set — `{ slots, schedules }` per service over\n *   the page's window — 30-second key bucket.\n *\n * Assembled, `loadBookingSeed` answers `{ services, resources, nextAvailable,\n * schedules, slots, generatedAt }`. The GUARDIAN (cookie-dependent) never goes\n * in; the page reads it on its own.\n *\n * A MISS builds from the `catalogue.ts` loaders, in parallel, so the rounding,\n * the 62-day bypass and every other bound there still applies — the edge entry\n * is one more layer in front, not a second way to ask Medal. An entry is only\n * stored when every part of it was read; a failure is served to this request\n * (absent from the seed, fetched on demand by the wizard) and is not pinned for\n * the next visitor.\n *\n * A HIT is re-filtered to now: an entry up to 30 s old may hold a slot that has\n * since started, and «next free» is derived after that filter.\n *\n * KEYS. `<edgePrefix>/<env>[-<version>]/…`, mapped onto storage keys by the\n * edge adapter (the Workers adapter puts the site's origin in front, because\n * Cache API entries belong to the zone). The environment is in the path\n * because staging and production can share a zone. The seed key holds the\n * local day (the window ends on a local midnight), the SORTED prefetch ids and\n * the 30 s bucket. The prefetch ids are always the output of `prefetchTargets`\n * over the catalogue — a deep link that names no bookable service falls back\n * to the default set — so the number of distinct keys per bucket is at most\n * one per bookable service plus one.\n *\n * STALENESS. A seed is at most 30 s older than the slot entry it was built\n * from, which `catalogue.ts` bounds at ~60 s: ~90 s for a booking made\n * anywhere else. The site's own create / move / cancel (and a SLOT_TAKEN)\n * delete every seed key containing an affected service in this location\n * (`expireBookingSeeds`), and first write a per-service expiry marker (plus\n * one location-wide marker, so a hit checks one key, not one per service) so\n * a build already in flight when the write landed does not store its\n * pre-write seed (it still serves it to its own request), and a hit built\n * before the write is not served; in OTHER locations such a seed\n * stays until its bucket turns, ≤30 s. Medal re-checks every slot at submit,\n * and the 409 already carries fresh openings, so a stale seed costs a retry,\n * never a double booking.\n */\n\nimport { normaliseCategory } from '../core/categories';\nimport { createClock } from '../core/clock';\nimport type { BookingConfig } from '../core/config';\nimport { serviceMatches } from '../core/deep-link';\nimport { createDto, toBookingDayDto, toBookingSlotDto } from '../core/dto';\nimport { firstOpeningPerResource } from '../core/next-available';\nimport type {\n  BookingDayDto,\n  BookingResourceDto,\n  BookingServiceDto,\n  BookingSlotDto,\n} from '../core/types';\nimport type { Catalogue } from './catalogue';\nimport {\n  type BookingCacheAdapter,\n  type BookingLogger,\n  type BookingTiming,\n  DEFAULT_EDGE_PREFIX,\n  inBackground,\n  timed,\n} from './options';\n\nconst SEED_BUCKET_MS = 30_000;\nconst SEED_TTL_S = 30;\nconst CATALOGUE_BUCKET_MS = 60_000;\nconst CATALOGUE_TTL_S = 60;\n\n/**\n * STALE-WHILE-REVALIDATE. The bucketed keys above keep a location warm only\n * while visitors keep coming; after a quiet minute the first visitor there\n * paid a full rebuild. So each build is ALSO kept under a «latest» key without\n * the bucket, and a bucket miss serves it at once while one rebuild runs\n * behind the response:\n *\n * - the catalogue (services, stylists) for up to `CATALOGUE_STALE_MAX_S`;\n * - a seed for up to `SEED_STALE_MAX_MS`, and ONLY when no create / move /\n *   cancel handled IN THIS LOCATION has touched its services since it was\n *   built (the expiry markers, kept at least that long, and awaited by the\n *   write routes before they answer). The markers are per location: a booking\n *   handled elsewhere, or made outside this site, can show as open here for at\n *   most `SEED_STALE_MAX_MS` — Medal answers that slot at submit with a 409\n *   carrying fresh openings.\n *\n * One refresh per key at a time in an isolate (`once`), and a refresh never\n * replaces a kept copy built later than its own (`isNewer`), so a burst of\n * visitors to a quiet location costs one rebuild and out-of-order finishes\n * cannot put older openings back.\n */\nconst CATALOGUE_STALE_MAX_S = 60 * 60;\nexport const SEED_STALE_MAX_MS = 5 * 60 * 1000;\n\n/**\n * The per-service expiry marker: the instant this location last saw a write\n * to the service (`expireBookingSeeds`). Outlives any seed build and any\n * «latest» seed that could still be served stale (`SEED_STALE_MAX_MS`).\n */\nconst MARKER_TTL_S = 10 * 60;\n\n/**\n * The location-wide marker (`anyExpiryMarkerKey`) is the instant of the last\n * write to ANY service here, so a hit reads one key instead of one per\n * prefetched service (up to `window.prefetchLimit`). Only when it is at or\n * within this margin of a seed's build instant are the per-service markers\n * read, to tell a write to one of the seed's services from a write to another\n * one. The margin covers writes racing: the edge has no compare-and-set, so\n * the location-wide marker can end on an earlier write whose put landed after\n * a later one's; the per-service markers still hold the later. One seed\n * bucket: far longer than an edge put takes, and a hit within it of a write\n * costs the per-service reads it always cost before.\n *\n * When the location-wide marker cannot be read, or the adapter cannot store\n * it, the per-service markers are read instead. When it is simply absent (no\n * write here within `MARKER_TTL_S`, or its put failed while a per-service put\n * succeeded) the hit is served; as with any marker that failed, the\n * background deletes and the 30 s bucket still bound that seed.\n */\nconst MARKER_RACE_MS = SEED_BUCKET_MS;\n\n/**\n * How long after the first delete the second one runs. The first can land\n * BEFORE the write it answers is visible to a concurrent seed build: the slot\n * tag expiry is written in the platform's deferred work, and a booking-page\n * miss already in flight puts the seed it built from pre-booking slots once it\n * is done. Either puts a stale seed back after the first delete; the second\n * pass removes it. A build that starts after the tag expiry has landed reads\n * live.\n */\nexport const SEED_RECHECK_MS = 2_000;\n\nexport interface BookingCatalogue {\n  services: BookingServiceDto[];\n  /** `null` when the stylists could not be read; the wizard fetches them. */\n  resources: BookingResourceDto[] | null;\n}\n\nexport interface BookingSeed extends BookingCatalogue {\n  slots: Record<string, BookingSlotDto[]>;\n  schedules: Record<string, BookingDayDto[]>;\n  nextAvailable: Record<string, Record<string, number>>;\n  /** When the slot/schedule part was read from `catalogue.ts`. */\n  generatedAt: number;\n  /** The window the slots and schedules describe. */\n  fromTs: number;\n  toTs: number;\n}\n\ninterface StoredSeed {\n  slots: Record<string, BookingSlotDto[]>;\n  schedules: Record<string, BookingDayDto[]>;\n  generatedAt: number;\n}\n\n/** How a seed read ended, for `x-booking-seed` and the timing sink. */\nexport type SeedState = 'hit' | 'stale' | 'miss' | 'bypass';\n\nexport interface SeedOptions {\n  config: Pick<\n    BookingConfig,\n    'timeZone' | 'locale' | 'dayparts' | 'window' | 'categories' | 'fallbackCategory' | 'paths'\n  >;\n  cache: { edge: BookingCacheAdapter; environment: string; edgePrefix?: string };\n  logger: BookingLogger;\n  timing?: BookingTiming;\n}\n\nexport interface Seed {\n  /** The window the wizard shows and prefetches for, in local days. */\n  readonly RANGE_DAYS: number;\n  /** How many services to warm the cache with. */\n  readonly PREFETCH_LIMIT: number;\n  prefetchTargets(services: BookingServiceDto[], named: string | undefined): BookingServiceDto[];\n  prefetchKey(targets: readonly { id: string }[]): string;\n  seedBucket(now: number): number;\n  expiryMarkerKey(serviceId: string): string | null;\n  anyExpiryMarkerKey(): string | null;\n  catalogueKeyAt(now: number): string | null;\n  catalogueLatestKey(): string | null;\n  seedLatestKeyAt(key: string, now: number): string | null;\n  seedKeyAt(key: string, now: number): string | null;\n  loadBookingCatalogue(now?: number): Promise<BookingCatalogue>;\n  loadBookingSeed(named: string | undefined, now?: number): Promise<BookingSeed>;\n  allPrefetchKeys(services: BookingServiceDto[]): string[];\n  seedKeysFor(services: BookingServiceDto[], serviceIds: Iterable<string>, now: number): string[];\n  expireBookingSeeds(\n    serviceIds: Iterable<string>,\n    now?: number,\n    recheckAfterMs?: number\n  ): Promise<void>;\n  /** Test seam: forget in-flight refreshes. */\n  resetSeedRefreshes(): void;\n}\n\ntype SeedCatalogue = Pick<\n  Catalogue,\n  'cachedServices' | 'cachedResources' | 'cachedAvailability' | 'cachedSchedule'\n>;\n\nconst sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));\n\nexport function createSeed(options: SeedOptions, catalogue: SeedCatalogue): Seed {\n  const { config, logger } = options;\n  const { edge } = options.cache;\n  const SEED_PATH = options.cache.edgePrefix ?? DEFAULT_EDGE_PREFIX;\n  const RANGE_DAYS = config.window.rangeDays;\n  const PREFETCH_LIMIT = config.window.prefetchLimit;\n  const clock = createClock(config);\n  const { toBookingServiceDto, toBookingResourceDto } = createDto(config);\n\n  /** In-flight refreshes by edge key, shared by every request in this isolate. */\n  const inflight = new Map<string, Promise<unknown>>();\n\n  function once<T>(key: string, work: () => Promise<T>): Promise<T> {\n    const running = inflight.get(key) as Promise<T> | undefined;\n    if (running) return running;\n    const started = work().finally(() => inflight.delete(key));\n    inflight.set(key, started);\n    return started;\n  }\n\n  /** A package key as the adapter stores it, or `null` when it cannot store now. */\n  function storageKey(key: string): string | null {\n    return edge.key ? edge.key(key) : key;\n  }\n\n  function keyBase(): string | null {\n    const env = options.cache.environment || 'unknown';\n    const version = edge.version?.();\n    const base = `${SEED_PATH}/${encodeURIComponent(version ? `${env}-${version}` : env)}`;\n    return storageKey(base) === null ? null : base;\n  }\n\n  function keyed(path: (base: string) => string): string | null {\n    const base = keyBase();\n    return base === null ? null : storageKey(path(base));\n  }\n\n  /**\n   * The services worth prefetching, in order, capped at `PREFETCH_LIMIT`: the\n   * one the link names (it is the one the visitor is known to want), then the\n   * bookable `window.prefetchCategory` menu. An unknown value is ignored.\n   */\n  function prefetchTargets(\n    services: BookingServiceDto[],\n    named: string | undefined\n  ): BookingServiceDto[] {\n    const linked = named\n      ? services.find((service) => service.bookableOnline && serviceMatches(service, named))\n      : undefined;\n    const prefetchCategory = config.window.prefetchCategory;\n    const kids =\n      prefetchCategory === null\n        ? []\n        : services.filter(\n            (service) =>\n              service.bookableOnline &&\n              normaliseCategory(config, service.category) === prefetchCategory &&\n              service.id !== linked?.id\n          );\n    return [...(linked ? [linked] : []), ...kids].slice(0, PREFETCH_LIMIT);\n  }\n\n  /** The ids a seed is keyed by: sorted, so the order of the set is not a key. */\n  function prefetchKey(targets: readonly { id: string }[]): string {\n    return [...new Set(targets.map((target) => target.id))]\n      .sort()\n      .map(encodeURIComponent)\n      .join(',');\n  }\n\n  function seedBucket(now: number): number {\n    return Math.floor(now / SEED_BUCKET_MS);\n  }\n\n  function expiryMarkerKey(serviceId: string): string | null {\n    return keyed((base) => `${base}/gen/${encodeURIComponent(serviceId)}`);\n  }\n\n  /** The location-wide expiry marker: the last write to any service here. */\n  function anyExpiryMarkerKey(): string | null {\n    return keyed((base) => `${base}/gen-any`);\n  }\n\n  function catalogueKeyAt(now: number): string | null {\n    return keyed((base) => `${base}/catalogue/${Math.floor(now / CATALOGUE_BUCKET_MS)}`);\n  }\n\n  /** The catalogue kept past its bucket, for a stale-while-revalidate serve. */\n  function catalogueLatestKey(): string | null {\n    return keyed((base) => `${base}/catalogue/latest`);\n  }\n\n  /** One prefetch set's seed kept past its bucket, for the same local day. */\n  function seedLatestKeyAt(key: string, now: number): string | null {\n    if (key === '') return null;\n    return keyed((base) => `${base}/seed-latest/${clock.dayKey(now)}/${key}`);\n  }\n\n  /** The seed key for one prefetch set at one instant. */\n  function seedKeyAt(key: string, now: number): string | null {\n    if (key === '') return null;\n    return keyed((base) => `${base}/seed/${clock.dayKey(now)}/${key}/${seedBucket(now)}`);\n  }\n\n  async function edgeRead<T>(key: string): Promise<T | undefined> {\n    try {\n      return await edge.get<T>(key);\n    } catch (error) {\n      logger.warn({ err: error }, 'Could not read the booking seed from the colo cache');\n      return undefined;\n    }\n  }\n\n  function edgeWrite(key: string, value: unknown, ttlSeconds: number): Promise<void> {\n    return inBackground(edge, edge.put(key, value, ttlSeconds));\n  }\n\n  /** Whether a copy built at `builtAt` may replace what `key` holds now. */\n  async function isNewer(key: string, builtAt: number): Promise<boolean> {\n    const kept = await edgeRead<{ generatedAt?: number; builtAt?: number }>(key);\n    const keptAt = kept?.generatedAt ?? kept?.builtAt;\n    return typeof keptAt !== 'number' || builtAt >= keptAt;\n  }\n\n  /**\n   * One expiry marker, `null` when it is not set, or `failed` when the\n   * adapter cannot store it or the read fails.\n   */\n  async function readMarker<F>(key: string | null, failed: F): Promise<number | null | F> {\n    if (key === null) return failed;\n    try {\n      const hit = await edge.get<unknown>(key);\n      const mark = hit === undefined ? Number.NaN : Number(hit);\n      return Number.isFinite(mark) ? mark : null;\n    } catch {\n      return failed;\n    }\n  }\n\n  /**\n   * The latest per-service expiry marker among `targets`, or `null`. A marker\n   * that cannot be read counts as none: the delete passes and the 30 s bucket\n   * still bound it.\n   */\n  async function latestExpiry(targets: readonly { id: string }[]): Promise<number | null> {\n    const marks = await Promise.all(targets.map(({ id }) => readMarker(expiryMarkerKey(id), null)));\n    const valid = marks.filter((mark) => mark !== null);\n    return valid.length === 0 ? null : Math.max(...valid);\n  }\n\n  /**\n   * Whether a write touching one of `targets`' services was marked at or\n   * after an instant — i.e. a seed built then may hold pre-write openings.\n   * The location-wide marker is read once, as soon as this is called (so it\n   * runs alongside the seed read); the per-service markers only when it does\n   * not rule a write out (`MARKER_RACE_MS`), and then once for every check.\n   */\n  function expiryCheck(targets: readonly { id: string }[]): (since: number) => Promise<boolean> {\n    // Unreadable or unstorable: let the per-service markers decide.\n    const any = readMarker(anyExpiryMarkerKey(), 'unknown' as const);\n    let perService: Promise<number | null> | undefined;\n    return async (since) => {\n      const anyAt = await any;\n      if (anyAt === null || (anyAt !== 'unknown' && anyAt < since - MARKER_RACE_MS)) return false;\n      perService ??= latestExpiry(targets);\n      const latest = await perService;\n      return latest !== null && latest >= since;\n    };\n  }\n\n  async function writeExpiryMarkers(serviceIds: string[], at: number): Promise<void> {\n    const keys = [...serviceIds.map(expiryMarkerKey), anyExpiryMarkerKey()];\n    await Promise.all(\n      keys.map(async (key) => {\n        if (key === null) return;\n        try {\n          await edge.put(key, at, MARKER_TTL_S);\n        } catch (error) {\n          logger.warn({ err: error }, 'Could not mark booking seeds expired');\n        }\n      })\n    );\n  }\n\n  /** The catalogue straight from `catalogue.ts`. Services failing throws. */\n  async function readCatalogue(): Promise<{ catalogue: BookingCatalogue; complete: boolean }> {\n    const [services, resources] = await Promise.all([\n      catalogue.cachedServices(),\n      catalogue.cachedResources().then(\n        (list) => list.map(toBookingResourceDto),\n        (error: unknown) => {\n          logger.warn({ err: error }, 'Could not prefetch the stylists for the booking page');\n          return null;\n        }\n      ),\n    ]);\n    return {\n      catalogue: { services: services.map(toBookingServiceDto), resources },\n      complete: resources !== null,\n    };\n  }\n\n  /**\n   * The catalogue, from the edge when there is one. Throws when the services\n   * cannot be read — the one failure that replaces the wizard.\n   */\n  async function loadBookingCatalogue(now: number = Date.now()): Promise<BookingCatalogue> {\n    return timed(options.timing, 'catalogue', async () => {\n      const key = catalogueKeyAt(now);\n      if (key === null) return (await readCatalogue()).catalogue;\n      const hit = await edgeRead<BookingCatalogue>(key);\n      if (hit && Array.isArray(hit.services)) return hit;\n      const refresh = (): Promise<BookingCatalogue> =>\n        once(`${key}#refresh`, async () => {\n          const builtAt = Date.now();\n          const { catalogue: built, complete } = await readCatalogue();\n          if (complete && built.services.length > 0) {\n            await edgeWrite(key, built, CATALOGUE_TTL_S);\n            const latest = catalogueLatestKey();\n            if (latest !== null && (await isNewer(latest, builtAt))) {\n              await edgeWrite(latest, { ...built, builtAt }, CATALOGUE_STALE_MAX_S);\n            }\n          }\n          return built;\n        });\n      const latest = catalogueLatestKey();\n      const stale = latest === null ? undefined : await edgeRead<BookingCatalogue>(latest);\n      if (stale && Array.isArray(stale.services) && stale.services.length > 0) {\n        void inBackground(\n          edge,\n          refresh().catch((error: unknown) => {\n            logger.warn({ err: error }, 'Could not refresh the booking catalogue');\n          })\n        );\n        return stale;\n      }\n      return refresh();\n    });\n  }\n\n  /** One read per service, best effort per service. */\n  async function prefetchEach<T>(\n    targets: BookingServiceDto[],\n    what: string,\n    readOne: (serviceId: string) => Promise<T>\n  ): Promise<{ values: Record<string, T>; complete: boolean }> {\n    const fetched = await Promise.all(\n      targets.map(async (service) => {\n        try {\n          return [service.id, await readOne(service.id)] as const;\n        } catch (error) {\n          logger.warn({ err: error, serviceId: service.id }, `Could not prefetch ${what}`);\n          return null;\n        }\n      })\n    );\n    const entries = fetched.filter((entry) => entry !== null);\n    return { values: Object.fromEntries(entries), complete: entries.length === targets.length };\n  }\n\n  async function buildSeed(\n    targets: BookingServiceDto[],\n    fromTs: number,\n    toTs: number\n  ): Promise<{ seed: StoredSeed; complete: boolean }> {\n    const [slots, schedules] = await Promise.all([\n      prefetchEach(targets, 'availability', async (serviceId) =>\n        (await catalogue.cachedAvailability({ serviceId, fromTs, toTs })).flatMap(toBookingSlotDto)\n      ),\n      prefetchEach(targets, 'the schedule', async (serviceId) =>\n        (await catalogue.cachedSchedule({ serviceId, fromTs, toTs })).flatMap(toBookingDayDto)\n      ),\n    ]);\n    return {\n      seed: { slots: slots.values, schedules: schedules.values, generatedAt: fromTs },\n      complete: slots.complete && schedules.complete,\n    };\n  }\n\n  /** A stored seed as of `now`: slots that have started since it was built go. */\n  function freshen(seed: StoredSeed, now: number, toTs: number): StoredSeed {\n    const slots = Object.fromEntries(\n      Object.entries(seed.slots).map(([serviceId, list]) => [\n        serviceId,\n        list.filter((slot) => slot.startTs >= now && slot.startTs < toTs),\n      ])\n    );\n    return { ...seed, slots };\n  }\n\n  /**\n   * The seed for the page: the catalogue plus openings and hours for the\n   * prefetch set `named` selects. Throws only when the catalogue cannot be read.\n   *\n   * The state (hit / stale / miss / bypass) goes to the timing sink with the\n   * seed phase, for `x-booking-seed`.\n   */\n  async function loadBookingSeed(\n    named: string | undefined,\n    now: number = Date.now()\n  ): Promise<BookingSeed> {\n    const loaded = await loadBookingCatalogue(now);\n    const { toTs } = clock.window(now, RANGE_DAYS);\n    const targets = prefetchTargets(loaded.services, named);\n    let state: SeedState = 'miss';\n    const markSeed = (next: SeedState) => {\n      state = next;\n    };\n\n    const stored = await timed(\n      options.timing,\n      'seed',\n      async (): Promise<StoredSeed> => {\n        const key = seedKeyAt(prefetchKey(targets), now);\n        if (key === null) {\n          markSeed('bypass');\n          return (await buildSeed(targets, now, toTs)).seed;\n        }\n        // The location-wide marker is read alongside the seed, not after it:\n        // a hit costs no extra round trip, and one marker read whatever the\n        // size of the prefetch set.\n        const expired = expiryCheck(targets);\n        const hit = await edgeRead<StoredSeed>(key);\n        // A seed built before a write to one of its services was marked is\n        // not served, even inside its bucket: the write route awaited that\n        // marker before telling the visitor the slot was theirs, and the\n        // background delete may not have run yet.\n        if (hit?.slots && hit.schedules && !(await expired(hit.generatedAt))) {\n          markSeed('hit');\n          return freshen(hit, now, toTs);\n        }\n        const latestKey = seedLatestKeyAt(prefetchKey(targets), now);\n        const rebuild = (): Promise<StoredSeed> =>\n          once(`${key}#rebuild`, async () => {\n            // Before any Medal read: a write expired at or after this instant\n            // may not be in what this build reads, so its seed must not be\n            // stored.\n            const buildStart = Date.now();\n            const { seed, complete } = await buildSeed(targets, now, toTs);\n            if (complete && !(await expiryCheck(targets)(buildStart))) {\n              await edgeWrite(key, seed, SEED_TTL_S);\n              if (latestKey !== null && (await isNewer(latestKey, seed.generatedAt))) {\n                await edgeWrite(latestKey, seed, Math.ceil(SEED_STALE_MAX_MS / 1000));\n              }\n            }\n            return seed;\n          });\n        const stale = latestKey === null ? undefined : await edgeRead<StoredSeed>(latestKey);\n        if (\n          stale?.slots &&\n          stale.schedules &&\n          now - stale.generatedAt < SEED_STALE_MAX_MS &&\n          !(await expired(stale.generatedAt))\n        ) {\n          markSeed('stale');\n          void inBackground(\n            edge,\n            rebuild().catch((error: unknown) => {\n              logger.warn({ err: error }, 'Could not refresh the booking seed');\n            })\n          );\n          return freshen(stale, now, toTs);\n        }\n        markSeed('miss');\n        return rebuild();\n      },\n      () => ({ state })\n    );\n\n    // Only alongside a stylist list: «next free» with nobody to hang it on is\n    // not a seed the wizard can use, and it fetches both together instead.\n    const nextAvailable =\n      loaded.resources === null\n        ? {}\n        : Object.fromEntries(\n            Object.entries(stored.slots).map(([serviceId, slots]) => [\n              serviceId,\n              firstOpeningPerResource(slots),\n            ])\n          );\n\n    return {\n      ...loaded,\n      slots: stored.slots,\n      schedules: stored.schedules,\n      nextAvailable,\n      generatedAt: stored.generatedAt,\n      fromTs: now,\n      toTs,\n    };\n  }\n\n  /**\n   * Every prefetch set the page can key a seed by: the default one and one per\n   * bookable service a deep link can name. Deterministic from the catalogue.\n   */\n  function allPrefetchKeys(services: BookingServiceDto[]): string[] {\n    const sets = [\n      prefetchTargets(services, undefined),\n      ...services\n        .filter((service) => service.bookableOnline)\n        .map((service) => prefetchTargets(services, service.id)),\n    ];\n    return [...new Set(sets.filter((set) => set.length > 0).map(prefetchKey))];\n  }\n\n  /**\n   * The edge keys to delete after a write touching `serviceIds`: every prefetch\n   * set containing one of them, in the current and the previous 30 s bucket (a\n   * seed from the previous bucket can still be read by a request that started\n   * in it). Sets not containing an affected service are left alone.\n   */\n  function seedKeysFor(\n    services: BookingServiceDto[],\n    serviceIds: Iterable<string>,\n    now: number\n  ): string[] {\n    const affected = new Set(serviceIds);\n    if (affected.size === 0) return [];\n    const keys = allPrefetchKeys(services).filter((key) =>\n      key.split(',').some((id) => affected.has(decodeURIComponent(id)))\n    );\n    const instants = [now, now - SEED_BUCKET_MS];\n    return [\n      ...new Set(\n        keys\n          .flatMap((key) => [\n            ...instants.map((at) => seedKeyAt(key, at)),\n            // The kept copy too: it must not be served stale after this write.\n            seedLatestKeyAt(key, now),\n          ])\n          .filter((k) => k !== null)\n      ),\n    ];\n  }\n\n  async function deleteSeeds(serviceIds: string[], now: number): Promise<void> {\n    const current = catalogueKeyAt(now);\n    const previous = catalogueKeyAt(now - CATALOGUE_BUCKET_MS);\n    // Nothing can be keyed: no seed was ever stored, so nothing to delete.\n    if (current === null || previous === null) return;\n    const kept =\n      (await edgeRead<BookingCatalogue>(current)) ?? (await edgeRead<BookingCatalogue>(previous));\n    const services = Array.isArray(kept?.services)\n      ? kept.services\n      : (await catalogue.cachedServices()).map(toBookingServiceDto);\n    await edge.delete(seedKeysFor(services, serviceIds, now));\n  }\n\n  /**\n   * Mark `serviceIds` expired (so an in-flight build started before now does\n   * not store its seed), then delete this location's seeds containing any of\n   * them, after a create / move / cancel or a SLOT_TAKEN — twice, the second\n   * time `recheckAfterMs` later (see `SEED_RECHECK_MS`). The deletes run on the\n   * adapter's `defer`, so they add nothing to the response; best effort — the\n   * write has already happened and the 30 s bucket is the backstop. A no-op\n   * when the edge adapter cannot store anything.\n   */\n  function expireBookingSeeds(\n    serviceIds: Iterable<string>,\n    now: number = Date.now(),\n    recheckAfterMs: number = SEED_RECHECK_MS\n  ): Promise<void> {\n    const ids = [...new Set(serviceIds)];\n    if (ids.length === 0 || keyBase() === null) return Promise.resolve();\n    const pass = (at: number) =>\n      deleteSeeds(ids, at).catch((error: unknown) => {\n        logger.warn({ err: error }, 'Could not expire booking seeds');\n      });\n    // The marker first, and returned: a write route awaits it before\n    // answering, so no kept seed from before the write passes `expiredSince`\n    // in this location once the visitor has their confirmation. The deletes\n    // follow in the background.\n    const marked = writeExpiryMarkers(ids, now);\n    void inBackground(\n      edge,\n      (async () => {\n        await marked;\n        await pass(now);\n        await sleep(recheckAfterMs);\n        // Re-derived at the time of the second pass: if the bucket turned in\n        // between, the first pass's bucket is now the «previous» one.\n        await pass(now + recheckAfterMs);\n      })()\n    );\n    return marked;\n  }\n\n  return {\n    RANGE_DAYS,\n    PREFETCH_LIMIT,\n    prefetchTargets,\n    prefetchKey,\n    seedBucket,\n    expiryMarkerKey,\n    anyExpiryMarkerKey,\n    catalogueKeyAt,\n    catalogueLatestKey,\n    seedLatestKeyAt,\n    seedKeyAt,\n    loadBookingCatalogue,\n    loadBookingSeed,\n    allPrefetchKeys,\n    seedKeysFor,\n    expireBookingSeeds,\n    resetSeedRefreshes: () => inflight.clear(),\n  };\n}\n"],"mappings":"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"}

package/dist/next/server.d.mts

@@ -0,0 +1,26 @@
+import { BookingServerOptions } from "./options.mjs";
+import "./runtime.mjs";
+import { BookingHandler, createBookingHandlerFor } from "./handler.mjs";
+import { BookingPageResult, ManagePageResult, PageSwitches, PortalPageResult } from "./loaders.mjs";
+import { Portal } from "./portal.mjs";
+//#region src/next/server.d.ts
+type SearchParams = Record<string, string | string[] | undefined>;
+export interface BookingServer {
+  handler: ReturnType<typeof createBookingHandlerFor>;
+  portal: Portal;
+  loadBookingPage(args?: PageSwitches & {
+    searchParams?: SearchParams;
+  }): Promise<BookingPageResult>;
+  loadManagePage(token: string, switches?: PageSwitches): Promise<ManagePageResult>;
+  loadPortalPage(switches?: PageSwitches): Promise<PortalPageResult>;
+}
+export declare function createBookingServer(options: BookingServerOptions): BookingServer;
+export declare function createBookingHandler(options: BookingServerOptions): BookingHandler;
+export declare function createPortal(options: BookingServerOptions): Portal;
+export declare function loadBookingPage(options: BookingServerOptions, args?: PageSwitches & {
+  searchParams?: SearchParams;
+}): Promise<BookingPageResult>;
+export declare function loadManagePage(options: BookingServerOptions, token: string, switches?: PageSwitches): Promise<ManagePageResult>;
+export declare function loadPortalPage(options: BookingServerOptions, switches?: PageSwitches): Promise<PortalPageResult>;
+//#endregion
+//# sourceMappingURL=server.d.mts.map