@v-office/website-headless 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1423 @@
+//#region src/store/index.ts
+function createStore(initial) {
+	let state = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		getState: () => state,
+		setState(next) {
+			if (next === state) return;
+			state = next;
+			const current = [...listeners];
+			for (const listener of current) listener(state);
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+//#endregion
+//#region src/sdk.ts
+/**
+* Render `error` and its whole cause chain as indented JSON.
+*
+* Walks the chain because a cause nests (a `CoreSDKError` wrapping a thrown
+* transport object wrapping a response body). Skips `stack` — a backend
+* refusal is not diagnosed from the frames that asked, and the raw error is
+* one `console.error` away for the cases that are. Reads `name`/`message` by
+* hand because `Error` declares both non-enumerable, so `Object.entries`
+* alone would return an Error as `{}`.
+*
+* **`cause` is read by hand for exactly the same reason**, and it was missed
+* the first time — so this file shipped without the one property it exists to
+* print. Verified against the real class: `Object.keys(new CoreSDKError({…}))`
+* is `["source", "operation", "_tag"]`, and `cause`'s own descriptor carries
+* `enumerable: false`. `Object.entries` therefore never saw it, and every
+* `CoreSDKError` logged as the five bland fields above with the sentence that
+* names the fault dropped.
+*/
+function describeSdkError(error) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const unwrap = (value, depth) => {
+		if (value === null || typeof value !== "object") return value;
+		if (depth > 6) return "[truncated]";
+		if (seen.has(value)) return "[circular]";
+		seen.add(value);
+		if (Array.isArray(value)) return value.map((entry) => unwrap(entry, depth + 1));
+		const out = {};
+		if (value instanceof Error) {
+			out["name"] = value.name;
+			out["message"] = value.message;
+			if (value.cause !== void 0) out["cause"] = unwrap(value.cause, depth + 1);
+		}
+		for (const [key, entry] of Object.entries(value)) {
+			if (key === "stack") continue;
+			out[key] = unwrap(entry, depth + 1);
+		}
+		return out;
+	};
+	try {
+		return JSON.stringify(unwrap(error, 0), null, 2) ?? String(error);
+	} catch {
+		return String(error);
+	}
+}
+/**
+* Log a failed SDK call with the backend's reason, tagged by `scope`.
+*
+* `scope` names the SDK operation, not the component — `"quote.selectInsurance"`
+* rather than `"the extras panel"`. What the console needs to answer is which
+* call the backend refused; which button was on screen at the time is the part
+* the reporter already knows.
+*
+* Logs the description ALONE. Callers that also have the raw error in hand may
+* log it separately for a clickable stack; doubling it here would print every
+* failure twice on the surfaces that already do.
+*/
+function logSdkFailure(scope, error) {
+	console.error(`[sdk] ${scope} failed:`, describeSdkError(error));
+}
+//#endregion
+//#region src/quote.ts
+/** The two codes that mean "the stay WAS priced, but the rental's rate setup
+*  cannot be resolved to the single multi-rate a booking must be written
+*  against" — a v10 backend-configuration fault the guest has no part in.
+*
+*  `resolveV10MultiRate` matches the priced quote's service lines against the
+*  rental's multi-rate rows for the policy, then tie-breaks on `baseRentRate`,
+*  which only fires when EXACTLY ONE tied row carries it. A rental whose PMS
+*  holds several equivalent base-rent rows per cancellation policy leaves the
+*  tie unbroken, and the SDK reports the quote unavailable rather than guess a
+*  rate — the price alone does not identify which row the booking belongs to.
+*
+*  There is nothing an adopting site can do about the stay itself: it stays
+*  unbookable until the surplus rows are removed in the PMS. What the site owes
+*  the guest is honest copy — never the generic "not available", which asserts
+*  a booking conflict that does not exist. */
+const MULTI_RATE_CODES = ["AmbiguousMultiRate", "UnresolvableMultiRate"];
+/** True when an unavailable quote is a rate-configuration fault rather than a
+*  genuinely unbookable stay. Callers branch the MESSAGE on this and must keep
+*  booking disabled either way (SDK 2.16.0 MIGRATION, "Required Consumer
+*  Work"). */
+function isRateConfigurationFault(code) {
+	return code !== void 0 && MULTI_RATE_CODES.includes(code);
+}
+/** Flatten `quote.insurance` into the renderable choice, or undefined when the
+*  feed offers no real product — insurance switched off in the hub setup, or a
+*  backend that has none. On v10 the SDK attaches a fixed no-insurance
+*  placeholder to every quote, so this returns undefined there and every
+*  insurance surface downstream self-hides without a backend check anywhere. */
+function adaptInsurance(insurance) {
+	if (!insurance) return void 0;
+	const options = insurance.options.flatMap((option) => option.kind === "insurance" ? [{
+		id: option.id,
+		label: option.label,
+		formattedPrice: option.formattedPrice,
+		description: option.description,
+		logoUrl: option.logoUrl,
+		features: option.features ? [...option.features] : void 0,
+		resources: option.resources ? option.resources.map((r) => ({
+			label: r.label,
+			url: r.url
+		})) : void 0,
+		requiresTravelers: option.requiredInformation.kind === "travelers"
+	}] : []);
+	if (options.length === 0) return void 0;
+	return {
+		noneLabel: insurance.options.find((option) => option.kind === "none")?.label ?? "Keine Versicherung",
+		options,
+		selectedId: insurance.selected.kind === "insurance" ? insurance.selected.id : null
+	};
+}
+/** Flatten a GuestQuote into the renderable view. Values verbatim.
+*
+* DISCOUNTS: the SDK does not hand us a discount LINE. When the PMS applies a
+* price modifier (Frühbucher/Last-Minute, a voucher, a policy markup) it hangs
+* it off the charge line as `modifiers[]` — label plus signed amount — and puts
+* the pre-modifier figure in `totalBeforeModifiers`, leaving `appliedCharge`
+* already net. Render `appliedCharge` alone (what every adoption did until now)
+* and the saving is invisible: the guest sees only the reduced number and is
+* never told a discount applied.
+*
+* So each modifier becomes its own row, and the line above it switches to
+* `totalBeforeModifiers`. That pairing is not cosmetic — it is what makes the
+* card add up. A deduction row under an `appliedCharge` that has ALREADY been
+* reduced double-counts on sight: the column no longer sums to the total, and a
+* guest checking the arithmetic finds it wrong. Gross line, then the deduction,
+* then the remaining charges: 1.694,00 − 140,00 + 42,70 = 1.596,70.
+*
+* `bookingCardInformation.totalBeforeModifiers` is deliberately NOT rendered.
+* The deduction rows already carry the saving, and a struck-through "was" price
+* would state it a second time — as the one figure on the card that cannot be
+* checked by adding, and as a price claim the customer would have to stand
+* behind. The total stays the single net number.
+*/
+function adaptGuestQuote(quote) {
+	const lines = [];
+	for (const section of quote.bookingCardInformation.sections) for (const line of section.lines) {
+		lines.push({
+			label: line.item.position,
+			amount: line.item.totalBeforeModifiers ?? line.item.appliedCharge,
+			nested: false,
+			discount: false
+		});
+		for (const sub of line.subItems ?? []) {
+			lines.push({
+				label: sub.position,
+				amount: sub.totalBeforeModifiers ?? sub.appliedCharge,
+				nested: true,
+				discount: false
+			});
+			for (const mod of sub.modifiers ?? []) lines.push({
+				label: mod.label,
+				amount: mod.amount,
+				nested: true,
+				discount: true
+			});
+		}
+		for (const mod of line.item.modifiers ?? []) lines.push({
+			label: mod.label,
+			amount: mod.amount,
+			nested: false,
+			discount: true
+		});
+	}
+	return {
+		card: {
+			lines,
+			total: quote.bookingCardInformation.total
+		},
+		services: quote.additionalServices.map((s) => ({
+			id: s.id,
+			label: s.label,
+			charge: s.charge,
+			description: s.description,
+			maxPerBooking: s.maxPerBooking,
+			proposedQuantity: s.proposedQuantity ?? s.preSelectedQuantity ?? 0,
+			available: s.available !== false,
+			unavailableReason: s.unavailableReason
+		})),
+		policies: (quote.cancellationPolicies ?? []).map((p) => ({
+			id: p.id,
+			label: p.label,
+			selected: p.selected,
+			description: p.description,
+			markUpPercentage: p.markUpPercentage,
+			processingFee: p.processingFee,
+			rules: (p.rules ?? []).map((r) => ({
+				daysBeforeArrival: r.daysBeforeArrival,
+				refundPercentage: r.refundPercentage
+			})),
+			available: p.available !== false,
+			unavailableReason: p.unavailableReason
+		})),
+		voucher: quote.voucher ? {
+			code: quote.voucher.code,
+			status: quote.voucher.status,
+			message: quote.voucher.message
+		} : void 0,
+		insurance: adaptInsurance(quote.insurance)
+	};
+}
+/** Price a stay for `rentalId`. The caller owns the SDK instance and its
+*  lifecycle — pass a shared one to reuse its queue + cache across the caller's
+*  lifetime. `voucher` re-prices with a code (the PMS decides what it's worth). */
+async function fetchQuote(rentalId, period, occupancy, sdk, voucher) {
+	const result = await sdk.live.quote.quote({
+		locale: "de-DE",
+		rentalId,
+		period,
+		occupancy: {
+			adults: occupancy.adults,
+			children: occupancy.children,
+			babies: occupancy.babies,
+			pets: occupancy.pets,
+			...occupancy.childrenAges !== void 0 ? { childrenAges: occupancy.childrenAges } : {}
+		},
+		...voucher !== void 0 ? { voucher } : {}
+	});
+	if (result.status !== "available") return {
+		status: "unavailable",
+		reason: result.reason,
+		code: result.code
+	};
+	const view = adaptGuestQuote(result.quote);
+	return {
+		status: "available",
+		quote: view.card,
+		live: result.quote,
+		view
+	};
+}
+/** Pull a human reason from a rejected selection when the SDK provides one.
+*  Today only `UnavailableQuoteCombination` carries a `reason`; anything else
+*  returns undefined so the caller stays quiet (the UI already guards the
+*  guessable failures). Kept structural so a new reason-bearing error tag can
+*  be added without a type dependency. */
+function selectionErrorReason(error) {
+	if (error !== null && typeof error === "object" && "_tag" in error && error._tag === "UnavailableQuoteCombination" && "reason" in error && typeof error.reason === "string") return error.reason;
+}
+async function addQuoteService(quote, id, sdk) {
+	try {
+		const result = await sdk.live.quote.addAdditionalService({
+			quote,
+			id
+		});
+		return result.ok ? {
+			ok: true,
+			quote: result.quote
+		} : {
+			ok: false,
+			reason: selectionErrorReason(result.error)
+		};
+	} catch (error) {
+		logSdkFailure("quote.addAdditionalService", error);
+		return { ok: false };
+	}
+}
+async function removeQuoteService(quote, id, sdk) {
+	try {
+		const result = await sdk.live.quote.removeAdditionalService({
+			quote,
+			id
+		});
+		return result.ok ? {
+			ok: true,
+			quote: result.quote
+		} : {
+			ok: false,
+			reason: selectionErrorReason(result.error)
+		};
+	} catch (error) {
+		logSdkFailure("quote.removeAdditionalService", error);
+		return { ok: false };
+	}
+}
+/** Drop every additional-service selection from `quote`.
+*
+*  A fresh quote's selection state is not knowable from the service list. It is
+*  empty by default and carries the PMS's proposed quantities only when the
+*  project sets `shouldAddProposedAdditionalServiceAmount: true` — an SDK
+*  option a component cannot see — and the quote will not say which happened
+*  (`GuestQuote.selections` is behind an unexported symbol). Rather than branch
+*  on something invisible, a caller that needs a known starting point clears
+*  first and steps up from zero with `addQuoteService`. */
+async function clearQuoteServices(quote, sdk) {
+	try {
+		const result = await sdk.live.quote.clearAdditionalServices({ quote });
+		return result.ok ? {
+			ok: true,
+			quote: result.quote
+		} : {
+			ok: false,
+			reason: selectionErrorReason(result.error)
+		};
+	} catch (error) {
+		logSdkFailure("quote.clearAdditionalServices", error);
+		return { ok: false };
+	}
+}
+async function selectQuotePolicy(quote, id, sdk) {
+	try {
+		const result = await sdk.live.quote.selectCancellationPolicy({
+			quote,
+			id
+		});
+		return result.ok ? {
+			ok: true,
+			quote: result.quote
+		} : {
+			ok: false,
+			reason: selectionErrorReason(result.error)
+		};
+	} catch (error) {
+		logSdkFailure("quote.selectCancellationPolicy", error);
+		return { ok: false };
+	}
+}
+/** Select a travel-insurance product (`id`) or none (`null`). Unlike the
+*  service/policy calls the SDK returns the new GuestQuote directly and throws
+*  on failure (unknown id) — normalized here to the same QuoteSelectionResult
+*  the other selection helpers use, so a stale id is a silent no-op the caller
+*  handles by keeping the previous quote.
+*
+*  For a product that needs no traveler data this is the COMPLETE selection:
+*  the premium books with the rental via `booking.book`, which reads the plan
+*  off the quote. A product with `requiresTravelers` needs the pre-contract /
+*  payment / `bookInsurance` steps on top, which the checkout does not
+*  implement — it offers only the products it can complete. */
+async function selectQuoteInsurance(quote, id, sdk) {
+	try {
+		return {
+			ok: true,
+			quote: await sdk.live.quote.selectInsurance({
+				quote,
+				selection: id === null ? { kind: "none" } : {
+					kind: "insurance",
+					id
+				}
+			})
+		};
+	} catch (error) {
+		logSdkFailure("quote.selectInsurance", error);
+		return { ok: false };
+	}
+}
+/**
+* The concrete "free cancellation until" date for ONE policy — DERIVED, not
+* fabricated: the PMS states its rules relatively (`daysBeforeArrival` +
+* `refundPercentage`), so with the chosen arrival in hand the deadline is
+* plain arithmetic (arrival − daysBeforeArrival), the same category of
+* derivation as computing nights from a range.
+*
+* Uses the policy's full-refund (100%) rule. Returns null when the policy has
+* no full-refund rule OR the derived date is already in the past (booking
+* inside the window — advertising a bygone deadline would be wrong).
+*/
+/** The policy's full-refund rule, if it has one. The refund figure is the SDK's
+*  own formatted string ("100%"), so this reads it rather than comparing a
+*  number — the one place that pattern is written, because both the derived
+*  deadline and the "is this a refundable rate at all" question depend on it. */
+function fullRefundRule(policy) {
+	return policy?.rules.find((r) => /^\s*100\s*%/.test(r.refundPercentage));
+}
+function policyFreeCancellationUntil(policy, arrival) {
+	if (!policy) return null;
+	const fullRefund = fullRefundRule(policy);
+	if (!fullRefund) return null;
+	const until = new Date(arrival);
+	until.setHours(0, 0, 0, 0);
+	until.setDate(until.getDate() - fullRefund.daysBeforeArrival);
+	const today = /* @__PURE__ */ new Date();
+	today.setHours(0, 0, 0, 0);
+	return until >= today ? until : null;
+}
+/** The deadline for the stay as it stands — i.e. of the SELECTED policy.
+*  Kept as its own name because that is what a summary line means: not "some
+*  policy allows this" but "what you have chosen allows this". */
+function freeCancellationUntil(policies, arrival) {
+	return policyFreeCancellationUntil(policies.find((p) => p.selected) ?? policies[0], arrival);
+}
+/**
+* Price every selectable cancellation policy off ONE base quote, so a guest can
+* compare the policies by what each actually costs rather than by a percentage.
+*
+* WHY REAL BRANCHES AND NOT ARITHMETIC. `markUpPercentage` looks like enough to
+* compute the alternative price, and it is not: the modifier applies to the
+* RENT, while taxes and fees ride along untouched, so the change it makes to
+* the total is always smaller than the percentage says — and a guest who checks
+* the number against the total would find the site's own figure wrong. The
+* arithmetic is unavailable in any case: every amount the SDK returns is a
+* locale-formatted string, so computing on one means parsing it back, which
+* this file does for no other charge either. What the PMS prices is what the UI
+* shows.
+*
+* `selectCancellationPolicy` does NOT mutate its input — it returns a new quote
+* — so each policy can be branched off the same base and the branches held side
+* by side. Costs one SDK call per policy MINUS one: the already-selected policy
+* is the base quote itself. Sequential, because the API allows 1 req/s.
+*
+* A policy the PMS marks `available: false` is skipped rather than attempted:
+* selecting it would fail by definition, and a burnt request inside a 1 req/s
+* budget delays the ones that can succeed. It simply gets no branch, and the UI
+* renders it as the unselectable row it already is.
+*/
+async function pricePolicyBranches(base, sdk) {
+	const branches = [];
+	for (const policy of base.cancellationPolicies ?? []) {
+		if (policy.selected) {
+			branches.push({
+				id: policy.id,
+				quote: base,
+				view: adaptGuestQuote(base)
+			});
+			continue;
+		}
+		if (policy.available === false) continue;
+		const result = await selectQuotePolicy(base, policy.id, sdk);
+		if (!result.ok) continue;
+		branches.push({
+			id: policy.id,
+			quote: result.quote,
+			view: adaptGuestQuote(result.quote)
+		});
+	}
+	return branches;
+}
+//#endregion
+//#region src/booking-snapshot.ts
+/** Rental identity, parked by the checkout page (which has it from SSR) and
+*  folded into the snapshot at book time — the SDK seam that writes the
+*  snapshot never sees a rental name or a link. */
+const CHECKOUT_CONTEXT_KEY = "voffice:checkout-context";
+/** The finished record `/buchen/bestaetigung` reads. */
+const BOOKING_SNAPSHOT_KEY = "voffice:booking-return";
+/** `sessionStorage` throws outright in Safari's private mode and does not exist
+*  during SSR. NOTHING here may break a booking, so every access fails soft. */
+function readStored(key) {
+	try {
+		return typeof window === "undefined" ? null : window.sessionStorage.getItem(key);
+	} catch {
+		return null;
+	}
+}
+function writeStored(key, value) {
+	try {
+		if (typeof window !== "undefined") window.sessionStorage.setItem(key, value);
+	} catch {}
+}
+/** Park the rental's identity for the return page. Called by the checkout page
+*  on load — it is the last place in the flow that knows the rental by name. */
+function saveCheckoutContext(context) {
+	writeStored(CHECKOUT_CONTEXT_KEY, JSON.stringify(context));
+}
+function readCheckoutContext() {
+	const raw = readStored(CHECKOUT_CONTEXT_KEY);
+	if (!raw) return void 0;
+	try {
+		const parsed = JSON.parse(raw);
+		return typeof parsed.rentalName === "string" && parsed.rentalName ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The stay, read off the checkout URL rather than passed in: the island keeps
+* `?start`/`?end`/`?adults`/… in sync with the edited stay through
+* `replaceState`, so the address bar IS the live value at the moment of
+* booking — and `submitBooking` stays the two-argument SDK seam it is.
+*/
+function readStay() {
+	if (typeof window === "undefined") return {};
+	const params = new URLSearchParams(window.location.search);
+	const iso = (key) => {
+		const value = params.get(key);
+		return value && /^\d{4}-\d{2}-\d{2}$/.test(value) ? value : void 0;
+	};
+	const count = (key) => {
+		const value = Number(params.get(key));
+		return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+	};
+	const adults = count("adults");
+	return {
+		start: iso("start"),
+		end: iso("end"),
+		guests: adults > 0 ? {
+			adults,
+			children: count("children"),
+			babies: count("babies"),
+			pets: count("pets")
+		} : void 0
+	};
+}
+/**
+* Write the return page's record. Called by `submitBooking` the moment the
+* reservation exists — EARLIER than the SDK's "before submitting a payment
+* option", because that is when the booking number is born, and a guest who
+* settles by bank transfer never leaves the checkout at all.
+*
+* Never throws. The snapshot is a nicety; the booking is not.
+*/
+function saveBookingSnapshot(bookingNumber, quote) {
+	try {
+		const context = readCheckoutContext();
+		const snapshot = {
+			bookingNumber,
+			...context?.rentalName ? { rentalName: context.rentalName } : {},
+			...context?.location ? { location: context.location } : {},
+			...context?.href ? { href: context.href } : {},
+			...context?.images?.length ? { images: context.images } : {},
+			...readStay(),
+			total: adaptGuestQuote(quote).card.total
+		};
+		writeStored(BOOKING_SNAPSHOT_KEY, JSON.stringify(snapshot));
+	} catch {}
+}
+//#endregion
+//#region src/booking.ts
+/** Where the payment provider sends the guest back after an online payment
+*  (relative — the SDK/PSP resolves it against the site origin). */
+const CHECKOUT_RETURN_PATH = "/buchen/bestaetigung";
+/**
+* Create the booking. `quote` MUST be the live GuestQuote instance (with any
+* service/policy selections applied). USER-initiated only — this reserves for
+* real. Throws on transport/backend errors (the caller renders an honest
+* retry message; nothing was necessarily booked when it throws).
+*/
+async function submitBooking(quote, contact, sdk) {
+	const out = await sdk.live.booking.book({
+		quote,
+		contact: {
+			forename: contact.forename,
+			surname: contact.surname,
+			...contact.title ? { title: contact.title } : {},
+			address: {
+				street: contact.street,
+				...contact.housenumber ? { housenumber: contact.housenumber } : {},
+				postalcode: contact.postalcode,
+				city: contact.city,
+				countryCode: contact.countryCode
+			},
+			contactDetails: contact.phone ? {
+				email: contact.email,
+				phone: contact.phone
+			} : { email: contact.email },
+			...contact.note ? { note: contact.note } : {}
+		},
+		relativeRedirectUrl: CHECKOUT_RETURN_PATH
+	}).catch((error) => {
+		logSdkFailure("booking.book", error);
+		throw error;
+	});
+	saveBookingSnapshot(out.bookingNumber, quote);
+	const toView = (entry) => ({
+		kind: entry.kind,
+		label: entry.label,
+		dueOn: entry.dueOn,
+		paymentAt: entry.paymentAt,
+		lines: (entry.lines ?? []).map((l) => ({
+			label: l.label,
+			amount: l.amount
+		})),
+		amount: entry.amount,
+		options: [...entry.paymentOptions ?? []]
+	});
+	return {
+		bookingNumber: out.bookingNumber,
+		schedules: out.payment.schedule.map(toView),
+		alternatives: out.payment.alternatives.map(toView),
+		insurancePayments: (out.insurancePaymentOptions ?? []).flatMap((option) => option.kind === "external_url" ? [{
+			label: option.label,
+			url: option.url,
+			description: option.description
+		}] : [])
+	};
+}
+/** True for the option kinds `submitPaymentOption` can perform in-browser
+*  (redirect / form_post / stripe_checkout). Bank transfer is display-only. */
+function isSubmittableOption(option) {
+	return option.kind !== "bank_transfer";
+}
+/** Perform an online payment option (redirects the browser to the PSP).
+*  USER-initiated only.
+*
+*  Logged on failure, and this is the worst place in the flow to lose a reason:
+*  by the time a payment option is on screen THE RESERVATION ALREADY EXISTS
+*  (the SDK's `booking.md` says as much), so a failure here is an unpaid
+*  booking, not a failed one. The checkout's catch discards the error entirely
+*  — `.catch(() => setPayError(true))` — so without this a guest who cannot
+*  pay leaves no trace at all, on a booking someone now has to chase. */
+async function payWithOption(option, sdk) {
+	await sdk.live.booking.submitPaymentOption(option).catch((error) => {
+		logSdkFailure("booking.submitPaymentOption", error);
+		throw error;
+	});
+}
+//#endregion
+//#region src/checkout/card-order.ts
+function toBlocks(lines) {
+	const blocks = [];
+	for (const line of lines) if (!line.nested || blocks.length === 0) blocks.push({
+		key: line.label,
+		lines: [line]
+	});
+	else blocks[blocks.length - 1].lines.push(line);
+	return blocks;
+}
+function stabilizeCardOrder(view, order) {
+	const blocks = toBlocks(view.card.lines);
+	for (const block of blocks) if (!order.has(block.key)) order.set(block.key, order.size);
+	const sorted = [...blocks].sort((a, b) => order.get(a.key) - order.get(b.key));
+	return {
+		...view,
+		card: {
+			...view.card,
+			lines: sorted.flatMap((b) => b.lines)
+		}
+	};
+}
+//#endregion
+//#region src/checkout/insurance.ts
+/** Documents the insurer ships that are NOT part of the pre-contractual set,
+*  and are therefore not surfaced at all — neither listed nor gated.
+*
+*  One entry so far: `commonProductInformationsUrl`, which the SDK labels
+*  "Produktinformationen" and which is in fact the GDV Einwilligungs- und
+*  Schweigepflichtentbindungserklärung for health data. It is a consent the
+*  customer GIVES (§ 213 VVG, Art. 9 DSGVO), not information the insurer OWES:
+*  § 1 VVG-InfoV's twenty items contain no consent declaration, the document is
+*  generic GDV boilerplate identical across tariffs and hosted away from the
+*  contract documents, and it becomes operative at claim time rather than at
+*  conclusion. The insurer's own funnels do not surface it before conclusion
+*  either, which is the strongest evidence available for what it considers
+*  pre-contractually required.
+*
+*  Matched on the URL rather than the label, because labels are localized
+*  ("Produktinformationen" / "Product information") and a site may override
+*  them, whereas the file is one fixed document.
+*
+*  This is an EXCLUSION list, and that is why it is acceptable where an
+*  inclusion whitelist would not be. The two fail in opposite directions: if
+*  this pattern stops matching, the document simply reappears — a cosmetic
+*  regression. If an inclusion whitelist stops matching, a mandatory document
+*  silently vanishes — a legal defect nobody sees until a dispute. */
+const NON_PRECONTRACTUAL_RESOURCE = /Einwilligung_Erhebung/i;
+/** The plan's documents as the checkout treats them: what it lists, what the
+*  guest must open, and what makes a plan sellable at all read the SAME list,
+*  so a hidden document can never end up required-but-unlisted (which would be
+*  a gate the guest cannot close). */
+function shownInsuranceResources(option) {
+	return (option.resources ?? []).filter((resource) => !NON_PRECONTRACTUAL_RESOURCE.test(resource.url));
+}
+/** The insurance products a checkout can actually complete. Two gates, and
+*  this filter is where the layer's capability is declared — a site that adds a
+*  missing flow adds it HERE, upstream, never in its own copy.
+*
+*  1. **Technical.** Products that select with the id alone and book WITH the
+*     rental booking. One that demands per-traveler data first (traveler forms,
+*     pre-contract, SEPA mandate, a post-booking insurance call) needs a flow
+*     this layer does not implement — offering it would dead-end the guest.
+*
+*  2. **Legal.** The product must carry its `resources`, the insurer's
+*     pre-contractual documents (see "Mandatory pre-contractual documents"
+*     below for which duties they discharge). A product the feed sends WITHOUT
+*     them cannot be concluded lawfully here, so it self-hides rather than
+*     being sold undocumented — the same rule as (1), applied to a legal
+*     precondition instead of a technical one. */
+function selectableInsuranceOptions(insurance) {
+	return insurance.options.filter((option) => !option.requiresTravelers && shownInsuranceResources(option).length > 0);
+}
+/** The selected plan, but only when it is one the guest could actually pick
+*  here — so no price row can name a product the section above never showed. */
+function selectedInsuranceOption(insurance) {
+	if (!insurance) return void 0;
+	return selectableInsuranceOptions(insurance).find((option) => option.id === insurance.selectedId);
+}
+/** The identity of an insurance PRODUCT, as opposed to the id of one priced
+*  variant of it.
+*
+*  An insurer may band its tariffs by trip value, and then a plan id is not the
+*  product — it is the product AT one price. The same tariff comes back under a
+*  new id and a new premium the moment the total crosses a band. URV is the
+*  observed case: "RRV ohne SB Deutschland" is `RROR0625` at 56,00 € up to
+*  roughly 1.250 €, `RROR0725` at 65,00 € above that, `RROR0825` at 74,00 €
+*  above that again. Every extra, every policy markup and every stay change can
+*  cross a band, and each of them re-prices the quote — which is what makes the
+*  SDK re-fetch the insurer's plan list against the new total.
+*
+*  The label is what survives that: the same string in every band, and the name
+*  the guest actually chose, since it is what the radio shows. */
+function insuranceProductKey(option) {
+	return option.label;
+}
+/** The plan id to re-apply onto a re-priced quote, or null when there is
+*  nothing to do — no choice, already applied, or a product this feed no longer
+*  offers as a selectable one. The last case is why the feed is checked rather
+*  than the call simply attempted: a doomed selection would spend one of the
+*  rate-limited requests to be refused, and the guest ends up on "keine
+*  Versicherung" either way.
+*
+*  Matched by id first, then by product (see insuranceProductKey). That
+*  fallback is what keeps a banded re-price from silently un-selecting
+*  insurance the feed still sells: the SDK carries a selection across its
+*  refresh only on an exact id match, so a renamed-but-identical tariff reads
+*  to it as a plan that vanished, and a guest who only added a towel package
+*  lands back on "keine Versicherung". Re-applying picks the SAME product at
+*  its new premium — the one they would in fact be buying — and that premium is
+*  on screen in the radio, in the summary rail and above the submit button, so
+*  nothing about the change is hidden.
+*
+*  Checked against the SELECTABLE options, not the raw list: a plan the fresh
+*  feed carries without its documents (or newly demanding traveler data) is one
+*  the section no longer shows, so re-applying it would leave the quote
+*  carrying an insurance the page neither displays nor can take a document
+*  confirmation for. */
+function insuranceIdToReapply(fresh, wanted) {
+	if (!wanted || !fresh.insurance) return null;
+	if (fresh.insurance.selectedId === wanted.id) return null;
+	const options = selectableInsuranceOptions(fresh.insurance);
+	const match = options.find((option) => option.id === wanted.id) ?? options.find((option) => insuranceProductKey(option) === insuranceProductKey(wanted));
+	if (!match || match.id === fresh.insurance.selectedId) return null;
+	return match.id;
+}
+const NO_INSURANCE_DOCS = {
+	opened: /* @__PURE__ */ new Set(),
+	confirmedProduct: null
+};
+/** True while a chosen plan's document step is unfinished. No plan chosen (or
+*  "keine Versicherung") is never blocking — the duty attaches to the insurance
+*  contract, not to the stay. */
+function insuranceDocsPending(option, docs) {
+	if (!option) return false;
+	if (docs.confirmedProduct !== insuranceProductKey(option)) return true;
+	return !shownInsuranceResources(option).every((resource) => docs.opened.has(resource.url));
+}
+//#endregion
+//#region src/checkout/stay.ts
+/** Date → `YYYY-MM-DD` in LOCAL time — the vocabulary the URL handover and the
+*  SDK both use. Local on purpose (matches date-fns `format(date,
+*  "yyyy-MM-dd")`, which the sites' own lib/dates.ts uses): a calendar day
+*  picked in the browser must not shift across midnight UTC. */
+function isoDate(date) {
+	const pad = (n) => String(n).padStart(2, "0");
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+function occupancyOf(stay) {
+	return {
+		adults: stay.adults,
+		children: stay.children,
+		childrenAges: stay.childrenAges.length ? stay.childrenAges : void 0,
+		babies: stay.babies,
+		pets: stay.pets
+	};
+}
+/** The identity of a stay for "is the shown price still the shown stay"
+*  comparisons — every field that changes the quote, in one string. */
+function stayKeyOf(stay) {
+	return [
+		isoDate(stay.start),
+		isoDate(stay.end),
+		stay.adults,
+		stay.children,
+		stay.childrenAges.join(","),
+		stay.babies,
+		stay.pets
+	].join("|");
+}
+/** The stay as URL search params (`start`/`end`/`adults`/… — the same
+*  vocabulary the rental page reads + writes). */
+function stayParams(stay) {
+	const params = new URLSearchParams();
+	params.set("start", isoDate(stay.start));
+	params.set("end", isoDate(stay.end));
+	params.set("adults", String(stay.adults));
+	if (stay.children > 0) {
+		params.set("children", String(stay.children));
+		if (stay.childrenAges.length) params.set("childrenAges", stay.childrenAges.join(","));
+	}
+	if (stay.babies > 0) params.set("babies", String(stay.babies));
+	if (stay.pets > 0) params.set("pets", String(stay.pets));
+	return params.toString();
+}
+//#endregion
+//#region src/checkout/createCheckoutFlow.ts
+const initialRaw = () => ({
+	phase: { kind: "loading" },
+	live: null,
+	view: null,
+	counts: {},
+	quotedKey: null,
+	issue: null,
+	busy: false,
+	voucherApplied: null,
+	voucherError: null,
+	selectionError: null,
+	insuranceDocs: NO_INSURANCE_DOCS,
+	bookState: "idle",
+	confirmation: null,
+	payBusyKey: null,
+	payError: false
+});
+function createCheckoutFlow(initialOptions) {
+	let opts = initialOptions;
+	const { rentalId, getSdk } = initialOptions;
+	let raw = initialRaw();
+	const store = createStore(derive(raw, opts));
+	let holds = 0;
+	let gen = 0;
+	const lineOrder = /* @__PURE__ */ new Map();
+	const stabilize = (v) => stabilizeCardOrder(v, lineOrder);
+	let started = false;
+	let timer = null;
+	const patch = (next) => {
+		raw = {
+			...raw,
+			...next
+		};
+		store.setState(derive(raw, opts));
+		schedule();
+	};
+	const hold = () => {
+		holds += 1;
+		patch({ busy: true });
+	};
+	const release = () => {
+		holds -= 1;
+		patch({ busy: holds > 0 });
+	};
+	let lastInputs = [];
+	const schedule = () => {
+		if (!started) return;
+		const { stay, chosenPolicy } = opts;
+		const stayKey = stay ? stayKeyOf(stay) : null;
+		const inputs = [
+			stay,
+			stayKey,
+			raw.quotedKey,
+			raw.issue,
+			raw.confirmation,
+			raw.voucherApplied,
+			raw.counts,
+			raw.view,
+			chosenPolicy
+		];
+		if (inputs.length === lastInputs.length && inputs.every((v, i) => v === lastInputs[i])) return;
+		lastInputs = inputs;
+		if (timer) clearTimeout(timer);
+		timer = null;
+		if (!stay || !stayKey || raw.confirmation) return;
+		if (stay.adults < 1) return;
+		if (raw.quotedKey === stayKey || raw.issue?.key === stayKey) return;
+		const isInitial = raw.view == null;
+		timer = setTimeout(() => {
+			timer = null;
+			loadQuote(stay, stayKey, raw.voucherApplied, raw.view ? raw.counts : null, raw.view?.policies.find((p) => p.selected)?.id ?? chosenPolicy, selectedInsuranceOption(raw.view?.insurance));
+		}, isInitial ? 0 : 350);
+	};
+	const loadQuote = async (targetStay, key, voucher, wantCounts, wantPolicy, wantInsurance) => {
+		const myGen = ++gen;
+		const hadView = raw.view != null;
+		hold();
+		try {
+			const result = await fetchQuote(rentalId, {
+				start: isoDate(targetStay.start),
+				end: isoDate(targetStay.end)
+			}, occupancyOf(targetStay), getSdk(), voucher ?? void 0);
+			if (myGen !== gen) return;
+			if (result.status !== "available") {
+				const rateFault = isRateConfigurationFault(result.code);
+				if (rateFault) opts.onRateConfigurationFault?.({
+					code: result.code,
+					rentalId
+				});
+				const reason = rateFault ? opts.messages.rateFault : result.reason || opts.messages.unavailable;
+				if (!hadView) patch({ phase: {
+					kind: "unavailable",
+					reason
+				} });
+				else patch({ issue: {
+					key,
+					reason,
+					retryable: false
+				} });
+				return;
+			}
+			let quote = result.live;
+			const cleared = await clearQuoteServices(quote, getSdk());
+			if (!cleared.ok) throw new Error("clearAdditionalServices failed");
+			quote = cleared.quote;
+			let applied = null;
+			if (wantCounts) {
+				applied = {};
+				for (const service of result.view.services) {
+					const want = wantCounts[service.id] ?? 0;
+					let current = 0;
+					while (current < want) {
+						const next = await addQuoteService(quote, service.id, getSdk());
+						if (!next.ok) break;
+						quote = next.quote;
+						current++;
+					}
+					applied[service.id] = current;
+				}
+			}
+			const afterExtras = adaptGuestQuote(quote);
+			if (wantPolicy && opts.filterOfferedPolicies(afterExtras.policies, targetStay.start).some((p) => p.id === wantPolicy)) {
+				if (wantPolicy !== afterExtras.policies.find((p) => p.selected)?.id) {
+					const next = await selectQuotePolicy(quote, wantPolicy, getSdk());
+					if (next.ok) quote = next.quote;
+				}
+			}
+			const reapplyInsurance = insuranceIdToReapply(adaptGuestQuote(quote), wantInsurance);
+			if (reapplyInsurance) {
+				const next = await selectQuoteInsurance(quote, reapplyInsurance, getSdk());
+				if (next.ok) quote = next.quote;
+			}
+			if (myGen !== gen) return;
+			const nextView = adaptGuestQuote(quote);
+			const voucherLapsed = voucher !== null && nextView.voucher?.status === "not_applied";
+			patch({
+				live: quote,
+				view: stabilize(nextView),
+				counts: applied ?? Object.fromEntries(nextView.services.map((s) => [s.id, 0])),
+				quotedKey: key,
+				issue: null,
+				phase: { kind: "ready" },
+				...voucherLapsed ? {
+					voucherApplied: null,
+					voucherError: nextView.voucher?.message || opts.messages.voucherRejected
+				} : {}
+			});
+		} catch {
+			if (myGen !== gen) return;
+			if (!hadView) patch({ phase: { kind: "error" } });
+			else patch({ issue: {
+				key,
+				reason: opts.messages.quoteRefreshFailed,
+				retryable: true
+			} });
+		} finally {
+			release();
+		}
+	};
+	const mutate = async (fn) => {
+		if (holds > 0) return;
+		const myGen = gen;
+		hold();
+		patch({ selectionError: null });
+		try {
+			await fn(() => myGen !== gen);
+		} catch (error) {
+			console.error("[checkout] mutation failed:", error);
+		} finally {
+			release();
+		}
+	};
+	const updateFromLive = (next) => patch({
+		live: next,
+		view: stabilize(adaptGuestQuote(next))
+	});
+	/** Carry the guest's insurance choice onto a quote the SDK just re-priced:
+	*  a banded re-price renames the tariff rather than withdrawing it, which
+	*  would silently land the guest back on "keine Versicherung". Free — runs
+	*  against the list the refresh already returned. */
+	const carryInsurance = async (next, wanted) => {
+		const reapply = insuranceIdToReapply(adaptGuestQuote(next), wanted);
+		if (!reapply) return next;
+		const res = await selectQuoteInsurance(next, reapply, getSdk());
+		return res.ok ? res.quote : next;
+	};
+	return {
+		changeService(id, delta) {
+			mutate(async (stale) => {
+				const { live } = raw;
+				if (!live) return;
+				const chosen = store.getState().chosenInsurance;
+				const res = delta > 0 ? await addQuoteService(live, id, getSdk()) : await removeQuoteService(live, id, getSdk());
+				if (res.ok) {
+					const next = await carryInsurance(res.quote, chosen);
+					if (stale()) return;
+					patch({
+						live: next,
+						view: stabilize(adaptGuestQuote(next)),
+						counts: {
+							...raw.counts,
+							[id]: Math.max(0, (raw.counts[id] ?? 0) + delta)
+						}
+					});
+				} else if (res.reason) patch({ selectionError: res.reason });
+			});
+		},
+		selectInsurance(id) {
+			mutate(async (stale) => {
+				const { live } = raw;
+				if (!live) return;
+				const res = await selectQuoteInsurance(live, id, getSdk());
+				if (res.ok && !stale()) updateFromLive(res.quote);
+			});
+		},
+		openInsuranceDoc(url) {
+			const prev = raw.insuranceDocs;
+			if (prev.opened.has(url)) return;
+			patch({ insuranceDocs: {
+				...prev,
+				opened: new Set(prev.opened).add(url)
+			} });
+		},
+		confirmInsuranceDocs(productKey, confirmed) {
+			patch({ insuranceDocs: {
+				...raw.insuranceDocs,
+				confirmedProduct: confirmed ? productKey : null
+			} });
+		},
+		applyVoucher(code) {
+			mutate(async (stale) => {
+				const { stay } = opts;
+				if (!stay) return;
+				patch({ voucherError: null });
+				try {
+					const result = await fetchQuote(rentalId, {
+						start: isoDate(stay.start),
+						end: isoDate(stay.end)
+					}, occupancyOf(stay), getSdk(), code ?? void 0);
+					if (result.status !== "available") {
+						patch({ voucherError: isRateConfigurationFault(result.code) ? opts.messages.rateFault : result.reason || opts.messages.voucherFailed });
+						return;
+					}
+					let quote = result.live;
+					const applied = {};
+					const cleared = await clearQuoteServices(quote, getSdk());
+					if (!cleared.ok) throw new Error("clearAdditionalServices failed");
+					quote = cleared.quote;
+					for (const service of result.view.services) {
+						const want = raw.counts[service.id] ?? 0;
+						let current = 0;
+						while (current < want) {
+							const next = await addQuoteService(quote, service.id, getSdk());
+							if (!next.ok) break;
+							quote = next.quote;
+							current++;
+						}
+						applied[service.id] = current;
+					}
+					const afterExtras = adaptGuestQuote(quote);
+					const chosen = raw.view?.policies.find((p) => p.selected)?.id;
+					const fresh = afterExtras.policies.find((p) => p.selected)?.id;
+					if (chosen && chosen !== fresh) {
+						const next = await selectQuotePolicy(quote, chosen, getSdk());
+						if (next.ok) quote = next.quote;
+					}
+					const reapplyInsurance = insuranceIdToReapply(adaptGuestQuote(quote), selectedInsuranceOption(raw.view?.insurance));
+					if (reapplyInsurance) {
+						const next = await selectQuoteInsurance(quote, reapplyInsurance, getSdk());
+						if (next.ok) quote = next.quote;
+					}
+					const nextView = adaptGuestQuote(quote);
+					if (code !== null) {
+						const status = nextView.voucher?.status;
+						if (status === "not_applied") {
+							patch({ voucherError: nextView.voucher?.message || opts.messages.voucherRejected });
+							return;
+						}
+						if (status !== "applied" && raw.view && JSON.stringify(nextView.card) === JSON.stringify(raw.view.card)) {
+							patch({ voucherError: opts.messages.voucherRejected });
+							return;
+						}
+					}
+					if (stale()) return;
+					patch({
+						live: quote,
+						view: stabilize(nextView),
+						counts: applied,
+						voucherApplied: code
+					});
+				} catch (error) {
+					if (stale()) return;
+					console.error("[checkout] voucher failed:", error);
+					patch({ voucherError: opts.messages.voucherFailed });
+				}
+			});
+		},
+		book(contact) {
+			const s = store.getState();
+			const { live } = raw;
+			if (!live || raw.bookState === "submitting") return;
+			if (s.busy || s.issue || !s.stayKey || s.quotedKey !== s.stayKey) return;
+			if (s.documentsPending) return;
+			patch({ bookState: "submitting" });
+			const submit = async () => {
+				let quote = live;
+				const selected = quote.insurance?.selected;
+				const liveInsuranceId = selected?.kind === "insurance" ? selected.id : null;
+				const shownInsuranceId = s.chosenInsurance?.id ?? null;
+				if (liveInsuranceId !== shownInsuranceId) {
+					const res = await selectQuoteInsurance(quote, shownInsuranceId, getSdk());
+					if (!res.ok) throw new Error("insurance selection on the quote disagrees with the page and could not be reconciled");
+					quote = res.quote;
+					updateFromLive(quote);
+				}
+				return submitBooking(quote, contact, getSdk());
+			};
+			submit().then((result) => {
+				patch({
+					confirmation: result,
+					bookState: "idle"
+				});
+				if (typeof window !== "undefined") window.scrollTo({
+					top: 0,
+					behavior: "smooth"
+				});
+			}).catch((error) => {
+				console.error("[booking] book() failed:", error);
+				patch({ bookState: "error" });
+			});
+		},
+		pay(key, option) {
+			if (!isSubmittableOption(option) || raw.payBusyKey != null) return;
+			patch({
+				payError: false,
+				payBusyKey: key
+			});
+			payWithOption(option, getSdk()).catch(() => {
+				patch({
+					payError: true,
+					payBusyKey: null
+				});
+			});
+		},
+		clearIssue() {
+			patch({ issue: null });
+		},
+		getState: store.getState,
+		subscribe: store.subscribe,
+		update(next) {
+			const changed = next.stay !== opts.stay || next.chosenPolicy !== opts.chosenPolicy;
+			opts = next;
+			if (!changed) return;
+			store.setState(derive(raw, opts));
+			schedule();
+		},
+		start() {
+			if (started) return;
+			started = true;
+			lastInputs = [];
+			schedule();
+		},
+		dispose() {
+			started = false;
+			if (timer) clearTimeout(timer);
+			timer = null;
+			gen += 1;
+		}
+	};
+}
+function derive(raw, opts) {
+	const stayKey = opts.stay ? stayKeyOf(opts.stay) : null;
+	const chosenInsurance = selectedInsuranceOption(raw.view?.insurance);
+	const documentsPending = insuranceDocsPending(chosenInsurance, raw.insuranceDocs);
+	const pricePending = !!stayKey && raw.quotedKey !== stayKey && raw.issue?.key !== stayKey && (opts.stay?.adults ?? 0) >= 1;
+	const blocked = !raw.view || !stayKey || raw.quotedKey !== stayKey || raw.busy || !!raw.issue || documentsPending;
+	return {
+		phase: raw.phase,
+		view: raw.view,
+		counts: raw.counts,
+		busy: raw.busy,
+		issue: raw.issue,
+		selectionError: raw.selectionError,
+		quotedKey: raw.quotedKey,
+		stayKey,
+		pricePending,
+		blocked,
+		chosenInsurance,
+		insuranceDocs: raw.insuranceDocs,
+		documentsPending,
+		voucherApplied: raw.voucherApplied,
+		voucherError: raw.voucherError,
+		bookState: raw.bookState,
+		confirmation: raw.confirmation,
+		payBusyKey: raw.payBusyKey,
+		payError: raw.payError
+	};
+}
+//#endregion
+//#region src/checkout/validation.ts
+function normalizePhone(raw, dial = "49") {
+	const v = raw.replace(/[-./()]+/g, " ").replace(/\s+/g, " ").trim();
+	if (!v) return "";
+	if (v.startsWith("00")) return "+" + v.slice(2);
+	if (v.startsWith("0")) return "+" + dial + " " + v.slice(1);
+	return v;
+}
+function phoneError(raw, dial, c) {
+	const compact = normalizePhone(raw, dial).replace(/\s+/g, "");
+	if (!compact) return void 0;
+	if (/^\+[1-9]\d{6,14}$/.test(compact)) return void 0;
+	if (compact.startsWith("+")) return c.phoneInvalid;
+	return c.phoneNeedsDialCode;
+}
+function emailError(raw, c) {
+	const v = raw.trim();
+	if (!v) return c.emailRequired;
+	if (!/^[^@\s]+@[^@\s]+\.[^@\s]{2,}$/.test(v)) return c.emailInvalid;
+}
+/** Pattern and complaint in ONE entry, so a country can never gain a pattern
+*  without its message — an earlier split into two structures meant a pattern
+*  whose message lookup returned undefined would have ACCEPTED the invalid
+*  PLZ silently. The message reads off the copy so an adopter re-voices it
+*  like every other string; adding a country is a package release (a new copy
+*  key ships with its entry here). */
+const POSTAL_CODE_FORMATS = {
+	DE: {
+		pattern: /^\d{5}$/,
+		message: (c) => c.postalcodeInvalidDE
+	},
+	AT: {
+		pattern: /^\d{4}$/,
+		message: (c) => c.postalcodeInvalidAT
+	},
+	CH: {
+		pattern: /^\d{4}$/,
+		message: (c) => c.postalcodeInvalidCH
+	}
+};
+function postalcodeError(raw, country, c) {
+	const v = raw.trim();
+	if (!v) return c.postalcodeRequired;
+	const format = POSTAL_CODE_FORMATS[country];
+	if (format && !format.pattern.test(v)) return format.message(c);
+}
+function streetWarning(raw, c) {
+	const v = raw.trim();
+	if (!v) return void 0;
+	if (/(?:^|\s)\p{Nd}+\s*\p{L}?$/u.test(v)) return c.streetHouseNumberWarning;
+}
+function requiredMessages(c) {
+	return /* @__PURE__ */ new Map([
+		["forename", c.forenameRequired],
+		["surname", c.surnameRequired],
+		["street", c.streetRequired],
+		["city", c.cityRequired]
+	]);
+}
+const VALIDATED_FIELDS = [
+	"forename",
+	"surname",
+	"email",
+	"phone",
+	"street",
+	"postalcode",
+	"city"
+];
+/** Validate one named field. Takes the selected COUNTRY plus its calling code
+*  (`dial`): two validators depend on the country — the phone via the dial
+*  code, the PLZ via its format rule. The dial code is passed in rather than
+*  looked up because the ISO→dial mapping lives with the site's country
+*  register (its localized "Land" options), not here. */
+function fieldError(name, value, country, dial, c) {
+	if (name === "email") return emailError(value, c);
+	if (name === "phone") return phoneError(value, dial, c);
+	if (name === "postalcode") return postalcodeError(value, country, c);
+	const required = requiredMessages(c).get(name);
+	if (required) return value.trim() ? void 0 : required;
+}
+function detectCountry(countries) {
+	const known = new Set([...countries.featured, ...countries.all].map(([code]) => code));
+	const candidates = typeof navigator !== "undefined" ? navigator.languages?.length ? navigator.languages : [navigator.language] : [];
+	const regionOf = (tag, maximize) => {
+		try {
+			const locale = new Intl.Locale(tag);
+			return (maximize ? locale.maximize() : locale).region;
+		} catch {
+			return;
+		}
+	};
+	for (const tag of candidates) {
+		if (!tag || tag.toLowerCase().startsWith("en")) continue;
+		const region = regionOf(tag, true);
+		if (region && known.has(region)) return region;
+	}
+	for (const tag of candidates) {
+		if (!tag || !tag.toLowerCase().startsWith("en")) continue;
+		const region = regionOf(tag, false);
+		if (region && known.has(region)) return region;
+	}
+	return "DE";
+}
+//#endregion
+//#region src/checkout/structure.ts
+/**
+* The checkout's STRUCTURAL requirements — what must be on screen, in what
+* order, regardless of who produced the markup.
+*
+* WHY THIS EXISTS. Headless holds the RULES (the § 7 VVG document gate, the
+* stale-price booking guard) but no markup, so a site that renders its own
+* checkout UI can silently drop a legal obligation — the § 312j BGB
+* Button-Lösung wording, the insurance documents listed before the guest's
+* confirmation, the price stated directly above the order button — and every
+* unit test still passes. This module is a contract over the RENDERED result,
+* checked by the platform's publish gate for imported and custom checkouts
+* alike.
+*
+* Two halves:
+*   - `CHECKOUT_PARTS`: the `data-part` vocabulary. Imported components carry
+*     these attributes; a site's own markup must keep them so the gate (and
+*     a site's own CSS) can find the elements.
+*   - `CHECKOUT_STRUCTURE` + `assertCheckoutStructure(root)`: the requirements
+*     and a pure DOM check the smoke suite runs against the rendered checkout
+*     (a browser page or a jsdom document). Every requirement names the legal
+*     basis it exists for, so a failure message tells the reader WHY.
+*/
+const CHECKOUT_PARTS = {
+	/** The one place the guest is told the price they are about to owe. */
+	priceTotal: "checkout-price-total",
+	/** The § 312j order button. */
+	submit: "checkout-submit",
+	/** The terms line (AGB + privacy triggers). */
+	terms: "checkout-terms",
+	/** One link per mandatory insurance document (§ 7 VVG). */
+	insuranceDocument: "checkout-insurance-document",
+	/** The guest's receipt confirmation for those documents. */
+	insuranceConfirm: "checkout-insurance-confirm"
+};
+/** German "kostenpflichtig bestellen"-class labels the courts have accepted
+*  for § 312j Abs. 3 BGB. The check is on the RENDERED button text, so a site
+*  may re-voice the label — but only within this class. */
+const BUTTON_SOLUTION_PATTERN = /(zahlungspflichtig|kostenpflichtig)\s+(buchen|bestellen|reservieren)|jetzt\s+kaufen/i;
+const CHECKOUT_STRUCTURE = {
+	"submit-present": {
+		basis: "§ 312j Abs. 3 BGB (Button-Lösung)",
+		description: "exactly one order button carries data-part=checkout-submit"
+	},
+	"submit-wording": {
+		basis: "§ 312j Abs. 3 BGB (Button-Lösung)",
+		description: "the order button's visible text is a 'zahlungspflichtig buchen'-class label"
+	},
+	"total-before-submit": {
+		basis: "§ 312j Abs. 2 BGB (price stated immediately before the order)",
+		description: "a data-part=checkout-price-total precedes the order button in DOM order"
+	},
+	"terms-before-submit": {
+		basis: "§ 312d BGB / Art. 13 DSGVO (terms + privacy notice before contracting)",
+		description: "a data-part=checkout-terms precedes the order button"
+	},
+	"insurance-docs-before-confirm": {
+		basis: "§ 7 Abs. 1 VVG, § 4 VVG-InfoV (documents before the declaration)",
+		description: "when an insurance confirmation is rendered, at least one insurance document precedes it in DOM order"
+	}
+};
+function parts(root, name) {
+	return Array.from(root.querySelectorAll(`[data-part="${name}"]`));
+}
+function precedes(a, b) {
+	return (a.compareDocumentPosition(b) & 4) === 4;
+}
+/**
+* Check a rendered checkout. `root` is `document` in the smoke suite's browser
+* page, or a jsdom document in tests. Returns every violation found (empty =
+* compliant). The insurance rule is conditional on purpose: the duty attaches
+* to concluding an insurance contract, so a checkout that renders no
+* confirmation control has nothing to gate.
+*/
+/** The text a sighted guest sees: descendants hidden by the `hidden` attribute,
+*  `aria-hidden` or an inline display/visibility rule are excluded, so a legal
+*  phrase in a hidden span cannot satisfy the wording rule. Stylesheet-based
+*  hiding needs layout and is the smoke suite's browser run to catch. */
+function visibleText(el) {
+	let text = "";
+	for (const node of el.childNodes) if (node.nodeType === 3) text += node.textContent ?? "";
+	else if (node.nodeType === 1) {
+		const child = node;
+		if (child.hasAttribute("hidden") || child.getAttribute("aria-hidden") === "true") continue;
+		if (/display\s*:\s*none|visibility\s*:\s*hidden/i.test(child.getAttribute("style") ?? "")) continue;
+		text += ` ${visibleText(child)} `;
+	}
+	return text;
+}
+function assertCheckoutStructure(root) {
+	const violations = [];
+	const violate = (requirement, detail) => violations.push({
+		requirement,
+		basis: CHECKOUT_STRUCTURE[requirement].basis,
+		detail
+	});
+	const submits = parts(root, CHECKOUT_PARTS.submit);
+	if (submits.length !== 1) {
+		violate("submit-present", `found ${submits.length} order buttons`);
+		return violations;
+	}
+	const submit = submits[0];
+	const label = visibleText(submit).replace(/\s+/g, " ").trim();
+	if (!BUTTON_SOLUTION_PATTERN.test(label)) violate("submit-wording", `button text is "${label}"`);
+	if (!parts(root, CHECKOUT_PARTS.priceTotal).some((el) => precedes(el, submit))) violate("total-before-submit", "no price total before the order button");
+	if (!parts(root, CHECKOUT_PARTS.terms).some((el) => precedes(el, submit))) violate("terms-before-submit", "no terms line before the order button");
+	const confirms = parts(root, CHECKOUT_PARTS.insuranceConfirm);
+	if (confirms.length > 0) {
+		const docs = parts(root, CHECKOUT_PARTS.insuranceDocument);
+		if (docs.length === 0 || !confirms.every((c) => docs.every((d) => precedes(d, c)))) violate("insurance-docs-before-confirm", `${docs.length} document link(s), not all of them before every confirmation`);
+	}
+	return violations;
+}
+//#endregion
+export { BOOKING_SNAPSHOT_KEY, BUTTON_SOLUTION_PATTERN, CHECKOUT_CONTEXT_KEY, CHECKOUT_PARTS, CHECKOUT_RETURN_PATH, CHECKOUT_STRUCTURE, MULTI_RATE_CODES, NO_INSURANCE_DOCS, VALIDATED_FIELDS, adaptGuestQuote, addQuoteService, assertCheckoutStructure, clearQuoteServices, createCheckoutFlow, createStore, describeSdkError, detectCountry, emailError, fetchQuote, fieldError, freeCancellationUntil, fullRefundRule, insuranceDocsPending, insuranceIdToReapply, insuranceProductKey, isRateConfigurationFault, isSubmittableOption, isoDate, logSdkFailure, normalizePhone, occupancyOf, payWithOption, phoneError, policyFreeCancellationUntil, postalcodeError, pricePolicyBranches, removeQuoteService, saveBookingSnapshot, saveCheckoutContext, selectQuoteInsurance, selectQuotePolicy, selectableInsuranceOptions, selectedInsuranceOption, shownInsuranceResources, stabilizeCardOrder, stayKeyOf, stayParams, streetWarning, submitBooking };