riverbankcms 0.23.0 → 0.24.0

package/dist/{src-BPh_OivC.mjs → src-B03aw4Tv.mjs}

@@ -1478,7 +1478,7 @@ function toPositiveTicketQuantity(value) {
 * null when the total is not a positive whole number.
 */
 function deriveTotalTicketQuantity(lines) {
-	const total = lines.reduce((sum, line) => sum + line.quantity, 0);
+	const total = lines.reduce((sum, line$1) => sum + line$1.quantity, 0);
 	const parsed = toPositiveTicketQuantity(total);
 	return parsed.ok ? parsed.value : null;
 }
@@ -2001,8 +2001,8 @@ function resolveBookingTimezone(venueTimezone, siteDefaultTimezone) {
 	return venueTimezone ?? siteDefaultTimezone;
 }
 function resolveBookingTimeZoneId(...candidates) {
-	for (const candidate of candidates) {
-		const normalized = typeof candidate === "string" ? candidate.trim() : "";
+	for (const candidate$1 of candidates) {
+		const normalized = typeof candidate$1 === "string" ? candidate$1.trim() : "";
 		if (normalized && isValidBookingTimeZone(normalized)) {
 			return normalized;
 		}
@@ -2222,8 +2222,8 @@ function parseBookingLocalDate(value) {
 	const year = Number(match.groups.year);
 	const month = Number(match.groups.month);
 	const day = Number(match.groups.day);
-	const candidate = new Date(Date.UTC(year, month - 1, day, 12, 0, 0));
-	if (Number.isNaN(candidate.getTime()) || candidate.getUTCFullYear() !== year || candidate.getUTCMonth() + 1 !== month || candidate.getUTCDate() !== day) {
+	const candidate$1 = new Date(Date.UTC(year, month - 1, day, 12, 0, 0));
+	if (Number.isNaN(candidate$1.getTime()) || candidate$1.getUTCFullYear() !== year || candidate$1.getUTCMonth() + 1 !== month || candidate$1.getUTCDate() !== day) {
 		throw new Error(`Invalid booking date format: "${value}" (expected YYYY-MM-DD)`);
 	}
 	return {
@@ -2567,12 +2567,12 @@ function decideRangeLabels(span, context, profile) {
 		label: start
 	};
 }
-function presentRangeEndpoint(value, context, profile, label) {
+function presentRangeEndpoint(value, context, profile, label$1) {
 	const date = presentDate({
 		kind: "instant",
 		value
 	}, context, profile);
-	const time = label === undefined ? presentTime(value, context, profile) : `${presentClock(value, context, profile.clock)} ${label}`;
+	const time = label$1 === undefined ? presentTime(value, context, profile) : `${presentClock(value, context, profile.clock)} ${label$1}`;
 	return `${date}, ${time}`;
 }
 function presentNativeRange(span, context, format) {
@@ -3024,7 +3024,7 @@ function selectCategoryView(categories, services, filterCategoryId) {
 			layout: publicLayout()
 		};
 	}
-	const category = categories.find((candidate) => candidate.id === filterCategoryId);
+	const category = categories.find((candidate$1) => candidate$1.id === filterCategoryId);
 	if (category === undefined) {
 		return {
 			kind: "fallback-all",
@@ -3113,6 +3113,169 @@ const RECTIFICATION_HISTORY_PROPAGATION_PLANS = {
 	blocked_immutable_history: { kind: "blocked_immutable_history" }
 };
 
+//#endregion
+//#region ../core/src/map-drawing/model.ts
+const MAX_DRAWING_BYTES = 1024 * 1024;
+const DRAWING_SIZE = 800;
+const DRAWING_SCHEMA_VERSION = 2;
+const DRAWING_GENERATOR_VERSION = 3;
+/** Current real city extracts fit with >2x headroom; reservations precede allocation. */
+const DRAWING_DECODE_LIMITS = {
+	pathsPerFeature: 2048,
+	verticesPerPath: 8192,
+	verticesPerFeature: 32768,
+	featuresPerLayer: 1e4,
+	featuresPerTile: 16e3,
+	featuresPerAttempt: 6e4,
+	verticesPerAttempt: 1e6
+};
+/**
+* The two fixed framings. Neighbourhood draws 1 m per view-box unit, wider 4 m, so the same stroke and label
+* sizes read well in both. The wider view leaves out buildings, distant paths and small green patches, which turn to
+* noise at that scale. `minParkArea` is in square view-box units. Labels go to the nearest streets first, with a
+* minor street counted as `minorLabelDistance` times further away than it is, so the wider view names main roads.
+*/
+const FRAMINGS = [{
+	name: "neighbourhood",
+	radiusMeters: 400,
+	zoom: 15,
+	roads: [
+		"major",
+		"minor",
+		"path"
+	],
+	maxPathDistance: 800,
+	buildings: true,
+	minParkArea: .3,
+	maxLabels: 6,
+	minorLabelDistance: 1.5
+}, {
+	name: "wider",
+	radiusMeters: 1600,
+	zoom: 14,
+	roads: [
+		"major",
+		"minor",
+		"path"
+	],
+	maxPathDistance: 100,
+	buildings: false,
+	minParkArea: 40,
+	maxLabels: 5,
+	minorLabelDistance: 4
+}];
+const tilePoint = z.tuple([z.number().finite().min(-8192).max(12288), z.number().finite().min(-8192).max(12288)]).readonly();
+const paths = z.array(z.array(tilePoint).min(2).max(DRAWING_DECODE_LIMITS.verticesPerPath).readonly()).min(1).max(DRAWING_DECODE_LIMITS.pathsPerFeature).readonly();
+const featureFields = {
+	kind: z.string().max(80),
+	name: z.string().trim().max(60).regex(/^[^<>\u0000-\u001f\u007f]*$/).nullish().transform((value) => value === undefined || value === null || value === "" ? null : value),
+	sortRank: z.number().finite().min(-1e4).max(1e4).default(0),
+	paths: paths.refine((value) => value.reduce((n, path) => n + path.length, 0) <= DRAWING_DECODE_LIMITS.verticesPerFeature)
+};
+/** An unusable optional label must not discard otherwise valid road geometry. */
+function normalizeMapDrawingName(value) {
+	const parsed = featureFields.name.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+const feature = z.discriminatedUnion("geometry", [z.strictObject({
+	...featureFields,
+	layer: z.literal("roads"),
+	geometry: z.literal("line")
+}).readonly(), z.strictObject({
+	...featureFields,
+	layer: z.enum([
+		"earth",
+		"water",
+		"landuse",
+		"buildings"
+	]),
+	geometry: z.literal("polygon")
+}).refine((value) => value.paths.every((ring) => ring.length >= 3)).readonly()]);
+const tile = z.strictObject({
+	z: z.union([z.literal(14), z.literal(15)]),
+	x: z.number().int().nonnegative(),
+	y: z.number().int().nonnegative(),
+	extent: z.literal(4096),
+	features: z.array(feature).max(DRAWING_DECODE_LIMITS.featuresPerTile).readonly()
+}).refine((value) => value.x < 2 ** value.z && value.y < 2 ** value.z).readonly();
+const mapDrawingInputSchema = z.strictObject({
+	buildId: z.string().regex(/^\d{8}$/),
+	tileSchemaVersion: z.string().regex(/^4\.\d+\.\d+$/),
+	pin: z.lazy(() => locationPinSchema),
+	tiles: z.array(tile).min(1).max(96).readonly()
+}).superRefine((value, ctx) => {
+	const features = value.tiles.flatMap((item) => item.features);
+	if (features.length > DRAWING_DECODE_LIMITS.featuresPerAttempt || features.reduce((sum, item) => sum + item.paths.reduce((count, path) => count + path.length, 0), 0) > DRAWING_DECODE_LIMITS.verticesPerAttempt) {
+		ctx.addIssue({
+			code: "custom",
+			message: "Decoded geometry exceeds the attempt budget."
+		});
+	}
+}).readonly();
+const point = z.tuple([z.number().min(0).max(DRAWING_SIZE), z.number().min(0).max(DRAWING_SIZE)]).readonly();
+const polygon = z.strictObject({
+	kind: z.literal("polygon"),
+	fillRule: z.literal("evenodd"),
+	className: z.enum([
+		"map-land",
+		"map-water",
+		"map-park",
+		"map-building"
+	]),
+	rings: z.array(z.array(point).min(3).max(8192).readonly()).min(1).max(DRAWING_DECODE_LIMITS.pathsPerFeature).readonly()
+}).readonly();
+const line = z.strictObject({
+	kind: z.literal("line"),
+	className: z.enum([
+		"map-road-major-casing",
+		"map-road-major",
+		"map-road-minor-casing",
+		"map-road-minor",
+		"map-road-path"
+	]),
+	points: z.array(point).min(2).max(8192).readonly()
+}).readonly();
+const drawingPathSchema = z.discriminatedUnion("kind", [polygon, line]);
+const label = z.strictObject({
+	className: z.literal("map-label"),
+	haloClassName: z.literal("map-label-halo"),
+	text: z.string().trim().min(1).max(60).regex(/^[^<>\u0000-\u001f\u007f]*$/),
+	point,
+	angle: z.number().min(-90).max(90)
+}).readonly();
+const drawingFrameSchema = z.strictObject({
+	radiusMeters: z.union([z.literal(FRAMINGS[0].radiusMeters), z.literal(FRAMINGS[1].radiusMeters)]),
+	viewBox: z.tuple([
+		z.literal(0),
+		z.literal(0),
+		z.literal(800),
+		z.literal(800)
+	]).readonly(),
+	backgroundClass: z.literal("map-water"),
+	paths: z.array(drawingPathSchema).max(1800).readonly(),
+	labels: z.array(label).max(12).readonly(),
+	pin: z.strictObject({
+		className: z.literal("map-pin"),
+		point: z.tuple([z.literal(400), z.literal(400)]).readonly()
+	}).readonly()
+}).superRefine((value, ctx) => {
+	const count = value.paths.reduce((sum, path) => sum + (path.kind === "line" ? path.points.length : path.rings.reduce((n, ring) => n + ring.length, 0)), 0);
+	if (count > 5e4) ctx.addIssue({
+		code: "custom",
+		message: "Drawing exceeds its vertex budget."
+	});
+}).readonly();
+const mapDrawingSchema = z.strictObject({
+	schemaVersion: z.literal(DRAWING_SCHEMA_VERSION),
+	generatorVersion: z.literal(DRAWING_GENERATOR_VERSION),
+	buildId: z.string().regex(/^\d{8}$/),
+	tileSchemaVersion: z.string().regex(/^4\.\d+\.\d+$/),
+	frames: z.strictObject({
+		neighbourhood: drawingFrameSchema,
+		wider: drawingFrameSchema
+	}).readonly()
+}).refine((value) => value.frames.neighbourhood.radiusMeters === FRAMINGS[0].radiusMeters && value.frames.wider.radiusMeters === FRAMINGS[1].radiusMeters).refine((value) => new TextEncoder().encode(JSON.stringify(value)).byteLength <= MAX_DRAWING_BYTES, { error: "Drawing exceeds its byte budget." }).readonly();
+
 //#endregion
 //#region ../core/src/string.ts
 /**
@@ -3200,6 +3363,7 @@ const locationValueSchema = z.strictObject({
 	pin: locationPinSchema.nullable().default(null),
 	doorNote: z.string().trim().max(1e3).nullish().transform(trimmedStringOrNull),
 	addressMatch: locationAddressMatchSchema.nullable().default(null),
+	addressCheckSettled: z.literal(true).optional(),
 	ownerConfirmedPinAndAddress: z.boolean().default(false)
 }).superRefine((value, context) => {
 	if (value.address === null && value.pin === null) {
@@ -3216,6 +3380,13 @@ const locationValueSchema = z.strictObject({
 			message: "Address evidence requires an address."
 		});
 	}
+	if (value.address === null && value.addressCheckSettled) {
+		context.addIssue({
+			code: "custom",
+			path: ["addressCheckSettled"],
+			message: "A settled address check requires an address."
+		});
+	}
 	if (value.ownerConfirmedPinAndAddress && (value.address === null || value.pin === null)) {
 		context.addIssue({
 			code: "custom",
@@ -3232,7 +3403,8 @@ function parseLocationValue(input) {
 		issues: parsed.error.issues
 	});
 }
-function formatLocationAddress(address) {
+/** One display formatter: a known matching site country is redundant. */
+function formatLocationAddress(address, siteCountry) {
 	if (address === null) return null;
 	const parts = [
 		address.building,
@@ -3242,15 +3414,32 @@ function formatLocationAddress(address) {
 		address.locality,
 		address.region,
 		address.postalCode,
-		address.country
+		sameLocationCountry(address.country, siteCountry) ? null : address.country
 	];
 	return parts.filter((part) => part !== null).join(", ") || null;
 }
+const regionNames = new Intl.DisplayNames(["en"], { type: "region" });
+const countryIdentity = (country) => {
+	const text = country.trim();
+	const code = text.toUpperCase() === "UK" ? "GB" : text.toUpperCase();
+	return (code.length === 2 && /^[A-Z]{2}$/.test(code) ? regionNames.of(code) ?? text : text).toLowerCase();
+};
+function sameLocationCountry(country, siteCountry) {
+	return country !== null && Boolean(siteCountry?.trim()) && countryIdentity(country) === countryIdentity(siteCountry ?? "");
+}
+const publicLocationSchema = z.strictObject({
+	drawing: z.lazy(() => mapDrawingSchema).optional().catch(undefined),
+	address: locationAddressSchema.nullable(),
+	displayAddress: z.string().nullable().default(null),
+	pin: locationPinSchema.nullable(),
+	doorNote: z.string().max(1e3).nullable(),
+	attribution: z.array(locationAddressMatchSchema.unwrap().shape.attribution.unwrap().element).max(4).readonly()
+}).readonly();
 /** Permission belongs to the resource/source owner before this projection. */
-function projectPublicLocation(location) {
+function projectPublicLocation(location, siteCountry) {
 	return {
 		address: location.address,
-		displayAddress: formatLocationAddress(location.address),
+		displayAddress: formatLocationAddress(location.address, siteCountry),
 		pin: location.pin,
 		doorNote: location.doorNote,
 		attribution: location.addressMatch?.attribution ?? []
@@ -3274,6 +3463,73 @@ function toLocationCoordinates(value) {
 		lng: value.lng
 	};
 }
+/** Decide permission before loading or projecting the selected source. */
+function decideLocationSourcePermission(source, businessAddressVisibility) {
+	if (source === "business_address" && businessAddressVisibility === undefined) return { kind: "unresolved" };
+	return source === "business_address" && businessAddressVisibility === "hidden" ? { kind: "hidden" } : {
+		kind: "permitted",
+		source
+	};
+}
+function resolvePermittedLocation(permission, location, siteCountry) {
+	if (permission.kind !== "permitted") return permission;
+	return location === null ? {
+		kind: "missing",
+		source: permission.source
+	} : {
+		kind: "visible",
+		source: permission.source,
+		location: projectPublicLocation(location, siteCountry)
+	};
+}
+
+//#endregion
+//#region ../core/src/locationLinks.ts
+/** Both outbound actions use the arrival pin, never match evidence. */
+function locationMapLinks(input) {
+	const target = input.location != null ? `${input.location.lat},${input.location.lng}` : normalizeLocationAddressText(input.addressText);
+	if (target === null) return {
+		directions: null,
+		googleMaps: null
+	};
+	const directions = new URL("https://www.google.com/maps/dir/");
+	directions.searchParams.set("api", "1");
+	directions.searchParams.set("destination", target);
+	const search = new URL("https://www.google.com/maps/search/");
+	search.searchParams.set("api", "1");
+	search.searchParams.set("query", target);
+	return {
+		directions: directions.toString(),
+		googleMaps: search.toString()
+	};
+}
+
+//#endregion
+//#region ../core/src/stable-json.ts
+function stableJsonStringify(value) {
+	return JSON.stringify(sortStableJsonValue(value));
+}
+function sortStableJsonValue(value) {
+	if (value === null) return null;
+	if (typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) {
+			throw new TypeError("Stable JSON only supports finite numbers");
+		}
+		return value;
+	}
+	if (Array.isArray(value)) {
+		return value.map(sortStableJsonValue);
+	}
+	if (typeof value === "object") {
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) {
+			throw new TypeError("Stable JSON only supports plain objects");
+		}
+		return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, child]) => [key, sortStableJsonValue(child)]));
+	}
+	throw new TypeError(`Stable JSON does not support ${typeof value}`);
+}
 
 //#endregion
 //#region ../core/src/location-relationship.ts
@@ -3293,15 +3549,15 @@ function decideLocationRelationship(location) {
 	if (location === null) return { kind: "empty" };
 	if (location.pin === null) return { kind: "address_only" };
 	if (location.address === null) return { kind: "pin_only" };
-	if (location.addressMatch === null || location.addressMatch.precision === "unknown") {
+	if (location.addressMatch === null) {
 		return { kind: "unchecked" };
 	}
-	const { point, precision } = location.addressMatch;
-	const distanceMetres = locationDistanceMetres(point, location.pin);
-	const thresholdMetres = LOCATION_MATCH_THRESHOLDS_METRES[precision];
+	const { point: point$1, precision } = location.addressMatch;
+	const distanceMetres = locationDistanceMetres(point$1, location.pin);
+	const thresholdMetres = LOCATION_MATCH_THRESHOLDS_METRES[precision === "unknown" ? "building" : precision];
 	const beyondThreshold = distanceMetres > thresholdMetres * (1 + 8 * Number.EPSILON);
 	return {
-		kind: beyondThreshold ? "far" : precision === "building" ? "near" : "approximate",
+		kind: beyondThreshold ? "far" : precision === "building" || precision === "unknown" ? "near" : "approximate",
 		distanceMetres,
 		thresholdMetres,
 		precision
@@ -3315,6 +3571,7 @@ const spatialAddressParts = [
 	"country"
 ];
 const comparisonText = (text) => (text ?? "").trim().replace(/\s+/g, " ").toLowerCase();
+/** Address evidence identity excludes refinements such as unit, floor and region. */
 function sameMeaningfulAddress(a, b) {
 	if (a === null || b === null) return a === b;
 	return spatialAddressParts.every((part) => comparisonText(a[part]) === comparisonText(b[part]));
@@ -3322,12 +3579,21 @@ function sameMeaningfulAddress(a, b) {
 function samePin(a, b) {
 	return a === null || b === null ? a === b : a.lat === b.lat && a.lng === b.lng;
 }
+/** Spatial identity ignores unit/floor/region/note edits; picker reply tags share this rule. */
+function sameLocationSpatialPair(a, b) {
+	return a === null || b === null ? a === b : sameMeaningfulAddress(a.address, b.address) && samePin(a.pin, b.pin);
+}
 /** Edits cannot carry forward old confirmation or address evidence by accident. */
 function editLocationValue(previous, details) {
 	if (details.address === null && details.pin === null) return ok(null);
+	const authored = {
+		address: details.address,
+		pin: details.pin,
+		doorNote: details.doorNote
+	};
 	if (previous === null) {
 		return parseLocationValue({
-			...details,
+			...authored,
 			addressMatch: null,
 			ownerConfirmedPinAndAddress: false
 		});
@@ -3335,8 +3601,9 @@ function editLocationValue(previous, details) {
 	const sameAddress = sameMeaningfulAddress(previous.address, details.address);
 	const samePair = sameAddress && samePin(previous.pin, details.pin);
 	return parseLocationValue({
-		...details,
+		...authored,
 		addressMatch: sameAddress ? previous.addressMatch : null,
+		...sameAddress && previous.addressCheckSettled ? { addressCheckSettled: true } : {},
 		ownerConfirmedPinAndAddress: samePair && previous.ownerConfirmedPinAndAddress
 	});
 }
@@ -3365,6 +3632,21 @@ function decideLocationSave(location, activity) {
 		location
 	};
 }
+/** Opening lookup evidence may change provider facts only, never the owner's saved place. */
+function planLocationOpeningEvidence(previous, evidence) {
+	const parsed = parseLocationValue(evidence);
+	if (previous === null || !parsed.ok || parsed.value === null) return err({ kind: "invalid_location" });
+	const next = parsed.value;
+	const authored = (value) => ({
+		address: value.address,
+		pin: value.pin,
+		doorNote: value.doorNote,
+		ownerConfirmedPinAndAddress: value.ownerConfirmedPinAndAddress
+	});
+	if (stableJsonStringify(authored(previous)) !== stableJsonStringify(authored(next)) || next.addressMatch === null && next.addressCheckSettled !== true) return err({ kind: "invalid_location" });
+	if (stableJsonStringify(previous) === stableJsonStringify(next)) return ok(next);
+	return previous.addressMatch !== null || previous.addressCheckSettled === true ? err({ kind: "invalid_location" }) : ok(next);
+}
 
 //#endregion
 //#region ../core/src/location-migration.ts
@@ -3475,17 +3757,25 @@ function mapVenueAddress(address) {
 	};
 	return Object.values(structured).some((part) => displayComparison(part) !== "") ? structured : { street: firstText(address.formatted, address.summary) };
 }
-function checkDisplayText(result, text) {
+const displayTokens = (text) => (text ?? "").toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+/** Only redundant trailing country text is disposable; ordered address words must all survive. */
+function comparableDisplay(text, countries) {
+	const tokens = displayTokens(text);
+	const suffixIndex = tokens.findIndex((_token, index) => countries.some((country) => sameLocationCountry(tokens.slice(index).join(" "), country)));
+	return (suffixIndex < 0 ? tokens : tokens.slice(0, suffixIndex)).join(" ");
+}
+function checkDisplayText(result, text, siteCountry) {
 	if (!result.ok) return result;
 	const original = text?.trim() ?? "";
 	const derived = formatLocationAddress(result.value?.address ?? null);
-	return original.length > 0 && displayComparison(original) !== displayComparison(derived) ? err({
+	const countries = [result.value?.address?.country, siteCountry];
+	return original.length > 0 && comparableDisplay(original, countries) !== comparableDisplay(derived, countries) ? err({
 		kind: "display_address_conflict",
 		original,
 		derived
 	}) : result;
 }
-function convertBusiness(value) {
+function convertBusiness(value, siteCountry) {
 	if (value == null) return ok(null);
 	const parsed = businessAddressSchema.safeParse(value);
 	if (!parsed.success) return err({
@@ -3500,7 +3790,7 @@ function convertBusiness(value) {
 		postalCode: parsed.data.postalCode,
 		country: parsed.data.countryCode
 	}, parsed.data);
-	return checkDisplayText(result, parsed.data.displayAddress);
+	return checkDisplayText(result, parsed.data.displayAddress, siteCountry);
 }
 function convertCustom(value) {
 	if (value == null) return ok(null);
@@ -3514,7 +3804,7 @@ function convertCustom(value) {
 function convertLegacyLocation(input) {
 	switch (input.kind) {
 		case "venue": return convertVenue(input);
-		case "business": return convertBusiness(input.value);
+		case "business": return convertBusiness(input.value, input.siteCountry);
 		case "custom": return convertCustom(input.value);
 	}
 }
@@ -3526,7 +3816,7 @@ function normalizeCountryCode(value) {
 	return trimmed !== null ? trimmed.toUpperCase() : null;
 }
 function normalizeCoordinate(value) {
-	return typeof value === "number" && Number.isFinite(value) ? value : null;
+	return typeof value === "number" ? value : null;
 }
 function isLatitude(value) {
 	return value >= -90 && value <= 90;
@@ -3534,7 +3824,7 @@ function isLatitude(value) {
 function isLongitude(value) {
 	return value >= -180 && value <= 180;
 }
-function buildBusinessAddressDisplayText(input) {
+function buildBusinessAddressDisplayText(input, siteCountry) {
 	return formatLocationAddress({
 		building: null,
 		street: trimmedStringOrNull(input.addressLine1),
@@ -3544,7 +3834,7 @@ function buildBusinessAddressDisplayText(input) {
 		region: trimmedStringOrNull(input.region),
 		postalCode: trimmedStringOrNull(input.postalCode),
 		country: normalizeCountryCode(input.countryCode)
-	});
+	}, siteCountry);
 }
 function validateBusinessAddressDraft(input) {
 	const addressLine1 = trimmedStringOrNull(input.addressLine1);
@@ -3556,16 +3846,13 @@ function validateBusinessAddressDraft(input) {
 	const displayAddress = trimmedStringOrNull(input.displayAddress) ?? buildBusinessAddressDisplayText(input);
 	const lat = normalizeCoordinate(input.lat);
 	const lng = normalizeCoordinate(input.lng);
-	const errors = [];
-	if (addressLine1 === null) errors.push("missing_address_line_1");
-	if (locality === null) errors.push("missing_locality");
-	if (countryCode === null) errors.push("missing_country_code");
-	if (displayAddress === null) errors.push("missing_display_address");
-	if (lat === null) errors.push("missing_latitude");
-	else if (!isLatitude(lat)) errors.push("invalid_latitude");
-	if (lng === null) errors.push("missing_longitude");
-	else if (!isLongitude(lng)) errors.push("invalid_longitude");
-	if (errors.length > 0 || addressLine1 === null || locality === null || countryCode === null || displayAddress === null || lat === null || lng === null) {
+	const errors = [...missingPostalFields({
+		addressLine1,
+		locality,
+		countryCode,
+		displayAddress
+	}), ...businessPinErrors(lat, lng)];
+	if (errors.length > 0 || addressLine1 === null || locality === null || countryCode === null || displayAddress === null) {
 		return {
 			success: false,
 			errors
@@ -3598,6 +3885,95 @@ function businessAddressToAddressedLocation(address) {
 		lng: address.lng
 	};
 }
+/** Temporary postal/editor response adapter. Canonical storage never uses this shape. */
+function businessAddressFromLocation(location, siteCountry) {
+	if (location === null || location.address === null) return null;
+	const address = location.address;
+	const displayAddress = formatLocationAddress(address, siteCountry);
+	if (displayAddress === null) return null;
+	const pin = location.pin ?? {
+		lat: null,
+		lng: null
+	};
+	return {
+		addressLine1: [address.building, address.street].filter((part) => part !== null).join(", "),
+		addressLine2: [address.unit, address.floor].filter((part) => part !== null).join(", ") || null,
+		locality: address.locality ?? "",
+		region: address.region,
+		postalCode: address.postalCode,
+		countryCode: address.country ?? "",
+		displayAddress,
+		lat: pin.lat,
+		lng: pin.lng
+	};
+}
+/** Legacy editor inputs are explicit write adapters, never fallback storage readers. */
+function planBusinessLocationWrite(previous, input) {
+	if ("locationValue" in input && input.expectedLocationValue !== undefined) {
+		if (stableJsonStringify(previous) !== stableJsonStringify(input.expectedLocationValue)) return err({ kind: "invalid_location" });
+		return planLocationOpeningEvidence(previous, input.locationValue);
+	}
+	const planned = "locationValue" in input ? parseLocationValue(input.locationValue) : planLegacyBusinessLocation(previous, input.businessAddress);
+	if (!planned.ok) return err({ kind: "locationValue" in input ? "invalid_location" : "invalid_legacy_location" });
+	const decision = decideLocationSave(planned.value, "idle");
+	return decision.kind === "blocked" ? err({ kind: "unconfirmed_mismatch" }) : ok(decision.location);
+}
+function planLegacyBusinessLocation(previous, address) {
+	if (address === null) return ok(null);
+	if (previous === null) return convertLegacyBusinessEdit(previous, address);
+	const projection = businessAddressFromLocation(previous);
+	return projection !== null && sameBusinessPostalProjection(projection, address) ? editBusinessPin(previous, address) : convertLegacyBusinessEdit(previous, address);
+}
+function editBusinessPin(previous, address) {
+	const pin = locationPinSchema.nullable().safeParse(address.lat === null && address.lng === null ? null : {
+		lat: address.lat,
+		lng: address.lng
+	});
+	return pin.success ? editLocationValue(previous, {
+		address: previous.address,
+		pin: pin.data,
+		doorNote: previous.doorNote
+	}) : err({ kind: "invalid_location" });
+}
+function convertLegacyBusinessEdit(previous, address) {
+	const converted = convertLegacyLocation({
+		kind: "business",
+		value: address
+	});
+	if (!converted.ok || converted.value === null) return converted;
+	return editLocationValue(previous, {
+		address: converted.value.address,
+		pin: converted.value.pin,
+		doorNote: previous?.doorNote ?? null
+	});
+}
+function sameBusinessPostalProjection(a, b) {
+	const fields = [
+		"addressLine1",
+		"addressLine2",
+		"locality",
+		"region",
+		"postalCode",
+		"countryCode",
+		"displayAddress"
+	];
+	return fields.every((field) => (a[field] ?? "").trim().replace(/\s+/g, " ").toLowerCase() === (b[field] ?? "").trim().replace(/\s+/g, " ").toLowerCase());
+}
+function missingPostalFields(fields) {
+	const required = [
+		[fields.addressLine1, "missing_address_line_1"],
+		[fields.locality, "missing_locality"],
+		[fields.countryCode, "missing_country_code"],
+		[fields.displayAddress, "missing_display_address"]
+	];
+	return required.flatMap(([value, code]) => value === null ? [code] : []);
+}
+function businessPinErrors(lat, lng) {
+	if (lat === null && lng === null) return [];
+	const latitude = lat === null ? ["missing_latitude"] : !isLatitude(lat) ? ["invalid_latitude"] : [];
+	const longitude = lng === null ? ["missing_longitude"] : !isLongitude(lng) ? ["invalid_longitude"] : [];
+	return [...latitude, ...longitude];
+}
 
 //#endregion
 //#region ../core/src/try-async.ts
@@ -4702,12 +5078,12 @@ function parsePublicSocialLinks(value) {
 			});
 			continue;
 		}
-		const label = trimmedOptionalString(rawLink.label);
-		if (rawLink.kind === "custom" && label !== null && label !== undefined) {
+		const label$1 = trimmedOptionalString(rawLink.label);
+		if (rawLink.kind === "custom" && label$1 !== null && label$1 !== undefined) {
 			links.push({
 				id: id.value,
 				kind: "custom",
-				label,
+				label: label$1,
 				url: url.value
 			});
 			continue;
@@ -5892,10 +6268,10 @@ function parseFooterEngagementSection(value) {
 	});
 }
 function upsertFooterEngagementSection(composition, section) {
-	const hasEngagement = composition.sections.some((candidate) => candidate.kind === "engagement");
+	const hasEngagement = composition.sections.some((candidate$1) => candidate$1.kind === "engagement");
 	return validateFooterComposition({
 		...composition,
-		sections: hasEngagement ? composition.sections.map((candidate) => candidate.kind === "engagement" ? section : candidate) : [...composition.sections, section]
+		sections: hasEngagement ? composition.sections.map((candidate$1) => candidate$1.kind === "engagement" ? section : candidate$1) : [...composition.sections, section]
 	});
 }
 function removeFooterEngagementSection(composition) {
@@ -6956,9 +7332,9 @@ function selectSubmissionPreviewFields(schemaFields, submissions) {
 		if (id === null) return null;
 		const type = (field.type ?? "text").toString().toLowerCase();
 		if (shouldHideInPreview(type)) return null;
-		const label = trimmedStringOrNull(field.label?.toString()) ?? humanizeSubmissionFieldKey(id);
+		const label$1 = trimmedStringOrNull(field.label?.toString()) ?? humanizeSubmissionFieldKey(id);
 		const normalizedId = id.toLowerCase();
-		const normalizedLabel = label.toLowerCase();
+		const normalizedLabel = label$1.toLowerCase();
 		let score = 0;
 		if (PRIORITY_IDS.has(normalizedId)) score += 500;
 		if (normalizedId.includes("name") || normalizedLabel.includes("name")) score += 550;
@@ -6981,7 +7357,7 @@ function selectSubmissionPreviewFields(schemaFields, submissions) {
 		}
 		return {
 			id,
-			label,
+			label: label$1,
 			type,
 			score,
 			index
@@ -7514,33 +7890,6 @@ function generateUuidV4(cryptoSource = globalThis.crypto) {
 	return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
 }
 
-//#endregion
-//#region ../core/src/stable-json.ts
-function stableJsonStringify(value) {
-	return JSON.stringify(sortStableJsonValue(value));
-}
-function sortStableJsonValue(value) {
-	if (value === null) return null;
-	if (typeof value === "string" || typeof value === "boolean") return value;
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) {
-			throw new TypeError("Stable JSON only supports finite numbers");
-		}
-		return value;
-	}
-	if (Array.isArray(value)) {
-		return value.map(sortStableJsonValue);
-	}
-	if (typeof value === "object") {
-		const prototype = Object.getPrototypeOf(value);
-		if (prototype !== Object.prototype && prototype !== null) {
-			throw new TypeError("Stable JSON only supports plain objects");
-		}
-		return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, child]) => [key, sortStableJsonValue(child)]));
-	}
-	throw new TypeError(`Stable JSON does not support ${typeof value}`);
-}
-
 //#endregion
 //#region ../core/src/secret.ts
 /**
@@ -7943,14 +8292,14 @@ const BOOKING_DEFAULTS_BY_BEHAVIOUR = {
 		memberships: "off"
 	}
 };
-function verticalBookingPreset(id, verticalId, canonicalBehaviour, label, pluralLabel, description, availability$1 = "onboarding") {
+function verticalBookingPreset(id, verticalId, canonicalBehaviour, label$1, pluralLabel, description, availability$1 = "onboarding") {
 	return {
 		id,
 		verticalId,
 		canonicalBehaviour,
 		engine: BOOKING_ENGINE_BY_BEHAVIOUR[canonicalBehaviour],
 		availability: availability$1,
-		label,
+		label: label$1,
 		pluralLabel,
 		description
 	};
@@ -8826,6 +9175,616 @@ function resolvePublicSiteVisibility(input) {
 	return "live";
 }
 
+//#endregion
+//#region ../core/src/map-drawing/geometry.ts
+const VIEW_BOUNDS = {
+	left: 0,
+	top: 0,
+	right: 800,
+	bottom: 800
+};
+function samePoint(a, b) {
+	return a[0] === b[0] && a[1] === b[1];
+}
+function distance(a, b) {
+	return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+function roundCoordinate(value) {
+	const rounded = Math.round(value * 10) / 10;
+	return rounded === 0 ? 0 : rounded;
+}
+function roundPoint(point$1) {
+	return [roundCoordinate(point$1[0]), roundCoordinate(point$1[1])];
+}
+/** Liang–Barsky: one bounded segment, no fabricated connecting line across the viewport. */
+function clipSegment(a, b, bounds) {
+	const dx = b[0] - a[0], dy = b[1] - a[1];
+	const edges = [
+		[-dx, a[0] - bounds.left],
+		[dx, bounds.right - a[0]],
+		[-dy, a[1] - bounds.top],
+		[dy, bounds.bottom - a[1]]
+	];
+	const interval = edges.reduce((range, [p, q]) => {
+		if (range === null || p === 0 && q < 0) return null;
+		if (p === 0) return range;
+		const ratio = q / p;
+		const next = p < 0 ? [Math.max(range[0], ratio), range[1]] : [range[0], Math.min(range[1], ratio)];
+		return next[0] > next[1] ? null : next;
+	}, [0, 1]);
+	return interval === null ? null : [[a[0] + interval[0] * dx, a[1] + interval[0] * dy], [a[0] + interval[1] * dx, a[1] + interval[1] * dy]];
+}
+function segments(points, closed = false) {
+	return points.flatMap((start, index) => {
+		const end = points[index + 1] ?? (closed ? points[0] : undefined);
+		return end === undefined ? [] : [{
+			start,
+			end
+		}];
+	});
+}
+function clipLine(points, bounds) {
+	return segments(points).reduce((paths$1, { start, end }) => {
+		const segment = clipSegment(start, end, bounds);
+		if (segment === null || samePoint(segment[0], segment[1])) return paths$1;
+		const previous = paths$1[paths$1.length - 1];
+		const last = previous?.[previous.length - 1];
+		return previous !== undefined && last !== undefined && samePoint(last, segment[0]) ? [...paths$1.slice(0, -1), [...previous, segment[1]]] : [...paths$1, segment];
+	}, []);
+}
+function polygonEdges(bounds) {
+	const vertical = (x) => (a, b) => [x, a[1] + (b[1] - a[1]) * (x - a[0]) / (b[0] - a[0])];
+	const horizontal = (y) => (a, b) => [a[0] + (b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]), y];
+	return [
+		{
+			inside: (p) => p[0] >= bounds.left,
+			cross: vertical(bounds.left)
+		},
+		{
+			inside: (p) => p[0] <= bounds.right,
+			cross: vertical(bounds.right)
+		},
+		{
+			inside: (p) => p[1] >= bounds.top,
+			cross: horizontal(bounds.top)
+		},
+		{
+			inside: (p) => p[1] <= bounds.bottom,
+			cross: horizontal(bounds.bottom)
+		}
+	];
+}
+function clipPolygonEdge(points, edge) {
+	return segments(points, true).flatMap(({ start, end }) => {
+		const wasInside = edge.inside(start), isInside = edge.inside(end);
+		if (wasInside && isInside) return [end];
+		if (wasInside) return [edge.cross(start, end)];
+		return isInside ? [edge.cross(start, end), end] : [];
+	});
+}
+function clipPolygon(points, bounds) {
+	const first = points[0], last = points[points.length - 1];
+	const open = first !== undefined && last !== undefined && samePoint(first, last) ? points.slice(0, -1) : points;
+	return polygonEdges(bounds).reduce((ring, edge) => clipPolygonEdge(ring, edge), open);
+}
+function deviation(point$1, start, end) {
+	const dx = end[0] - start[0], dy = end[1] - start[1];
+	const fraction = Math.max(0, Math.min(1, ((point$1[0] - start[0]) * dx + (point$1[1] - start[1]) * dy) / (dx * dx + dy * dy || 1)));
+	return distance(point$1, [start[0] + fraction * dx, start[1] + fraction * dy]);
+}
+function simplifyChunk(points) {
+	const start = points[0], end = points[points.length - 1];
+	if (start === undefined || end === undefined || points.length <= 2) return points;
+	const furthest = points.slice(1, -1).reduce((best, point$1, index) => {
+		const error = deviation(point$1, start, end);
+		return error > best.error ? {
+			error,
+			index: index + 1
+		} : best;
+	}, {
+		error: .8,
+		index: -1
+	});
+	return furthest.index < 0 ? [start, end] : [...simplifyChunk(points.slice(0, furthest.index + 1)).slice(0, -1), ...simplifyChunk(points.slice(furthest.index))];
+}
+/** Douglas–Peucker in overlapping 256-point chunks bounds recursion/work on hostile zigzags. */
+function simplify(points, closed) {
+	const rounded = points.map(roundPoint);
+	const open = rounded.filter((point$1, index) => rounded[index - 1] === undefined || !samePoint(point$1, rounded[index - 1] ?? point$1));
+	const first = open[0], last = open[open.length - 1];
+	if (first === undefined || last === undefined) return [];
+	const input = closed && !samePoint(first, last) ? [...open, first] : open;
+	const kept = Array.from({ length: Math.ceil((input.length - 1) / 255) }, (_, index) => simplifyChunk(input.slice(index * 255, index * 255 + 256))).flatMap((chunk, index) => index === 0 ? chunk : chunk.slice(1));
+	const start = kept[0], end = kept[kept.length - 1];
+	return closed && start !== undefined && end !== undefined && samePoint(start, end) ? kept.slice(0, -1) : kept;
+}
+function expandBounds(bounds, by) {
+	return {
+		left: bounds.left - by,
+		top: bounds.top - by,
+		right: bounds.right + by,
+		bottom: bounds.bottom + by
+	};
+}
+function polygonArea(points) {
+	return Math.abs(segments(points, true).reduce((area, { start, end }) => area + start[0] * end[1] - end[0] * start[1], 0)) / 2;
+}
+
+//#endregion
+//#region ../core/src/map-drawing/projection.ts
+const EARTH_CIRCUMFERENCE = 2 * Math.PI * 6378137;
+const MERCATOR_LIMIT = 85.0511287798066;
+function createProjection(pin, radius) {
+	const latitude = pin.lat * Math.PI / 180;
+	const center = [(pin.lng + 180) / 360, (1 - Math.asinh(Math.tan(latitude)) / Math.PI) / 2];
+	const span = 2 * radius / (EARTH_CIRCUMFERENCE * Math.cos(latitude));
+	return {
+		center,
+		span,
+		project: (tile$1, point$1) => {
+			const x = (tile$1.x + point$1[0] / tile$1.extent) / 2 ** tile$1.z;
+			const y = (tile$1.y + point$1[1] / tile$1.extent) / 2 ** tile$1.z;
+			const wrapped = (x - center[0] + 1.5) % 1 - .5;
+			return [400 + wrapped / span * 800, 400 + (y - center[1]) / span * 800];
+		}
+	};
+}
+function tileBounds(tile$1, projection) {
+	const a = projection.project(tile$1, [0, 0]), b = projection.project(tile$1, [tile$1.extent, tile$1.extent]);
+	return {
+		left: a[0],
+		top: a[1],
+		right: b[0],
+		bottom: b[1]
+	};
+}
+function supportsProjection(pin, projection) {
+	return Math.abs(pin.lat) <= MERCATOR_LIMIT && projection.center[1] - projection.span / 2 >= 0 && projection.center[1] + projection.span / 2 <= 1;
+}
+
+//#endregion
+//#region ../core/src/map-drawing/features.ts
+const compareKey = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const greenKinds = [
+	"park",
+	"forest",
+	"wood",
+	"grass",
+	"meadow",
+	"garden",
+	"nature_reserve",
+	"protected_area",
+	"recreation_ground",
+	"village_green"
+];
+function polygonRole(feature$1) {
+	if (feature$1.layer === "earth") return "map-land";
+	if (feature$1.layer === "water") return feature$1.kind === "swimming_pool" ? null : "map-water";
+	if (feature$1.layer === "buildings") return "map-building";
+	return feature$1.layer === "landuse" && greenKinds.includes(feature$1.kind) ? "map-park" : null;
+}
+function roadRole(kind) {
+	if (kind === "highway" || kind === "major_road") return "major";
+	if (kind === "minor_road") return "minor";
+	return kind === "path" ? "path" : null;
+}
+function intersection(a, b) {
+	const bounds = {
+		left: Math.max(a.left, b.left),
+		top: Math.max(a.top, b.top),
+		right: Math.min(a.right, b.right),
+		bottom: Math.min(a.bottom, b.bottom)
+	};
+	return bounds.left >= bounds.right || bounds.top >= bounds.bottom ? null : bounds;
+}
+function canonicalRing(points) {
+	const head = points[0];
+	if (head === undefined) return [];
+	const first = points.reduce((best, point$1, index) => point$1[0] < best.point[0] || point$1[0] === best.point[0] && point$1[1] < best.point[1] ? {
+		point: point$1,
+		index
+	} : best, {
+		point: head,
+		index: 0
+	});
+	const forward = [...points.slice(first.index), ...points.slice(0, first.index)];
+	const backward = [first.point, ...forward.slice(1).reverse()];
+	return compareKey(JSON.stringify(forward), JSON.stringify(backward)) <= 0 ? forward : backward;
+}
+function canonicalLine(points) {
+	const reversed = points.slice().reverse();
+	return compareKey(JSON.stringify(points), JSON.stringify(reversed)) <= 0 ? points : reversed;
+}
+const CENTRE = [400, 400];
+function pinDistance(geometry) {
+	if (geometry.kind === "road") return segments(geometry.points).reduce((nearest, { start, end }) => Math.min(nearest, deviation(CENTRE, start, end)), Infinity);
+	return geometry.rings.reduce((best, ring) => ring.reduce((nearest, point$1) => Math.min(nearest, distance(point$1, CENTRE)), best), Infinity);
+}
+function candidate(geometry, rank) {
+	const key = JSON.stringify(geometry.kind === "polygon" ? geometry : {
+		kind: "road",
+		role: geometry.role,
+		points: geometry.points
+	});
+	return {
+		geometry,
+		rank,
+		key,
+		distance: pinDistance(geometry)
+	};
+}
+/**
+* Polygons are clipped a fraction past their tile edge so neighbouring tiles' fills overlap; clipped exactly,
+* anti-aliasing leaves a hairline of background along every tile seam. Fills must be opaque for this to hold.
+*/
+const SEAM_OVERLAP = .5;
+function projectFeature(tile$1, feature$1, projection) {
+	const bounds = intersection(expandBounds(tileBounds(tile$1, projection), feature$1.geometry === "polygon" ? SEAM_OVERLAP : 0), VIEW_BOUNDS);
+	if (bounds === null) return [];
+	const paths$1 = feature$1.paths.map((path) => path.map((point$1) => projection.project(tile$1, point$1)));
+	if (feature$1.geometry === "line") {
+		const role = roadRole(feature$1.kind);
+		return role ? paths$1.flatMap((path) => clipLine(path, bounds)).map((path) => canonicalLine(simplify(canonicalLine(path), false))).filter((path) => path.length >= 2 && segments(path).reduce((sum, { start, end }) => sum + distance(start, end), 0) >= 1).map((points) => candidate({
+			kind: "road",
+			role,
+			points,
+			name: feature$1.name
+		}, feature$1.sortRank)) : [];
+	}
+	const className = polygonRole(feature$1);
+	if (!className) return [];
+	const rings = paths$1.map((path) => simplify(canonicalRing(clipPolygon(path, bounds)), true)).filter((ring) => ring.length >= 3 && polygonArea(ring) >= .3).map(canonicalRing).slice().sort((a, b) => compareKey(JSON.stringify(a), JSON.stringify(b)));
+	return rings.length ? [candidate({
+		kind: "polygon",
+		fillRule: "evenodd",
+		className,
+		rings
+	}, feature$1.sortRank)] : [];
+}
+function deduplicate(candidates) {
+	return candidates.slice().sort((a, b) => compareKey(a.key, b.key) || a.rank - b.rank || compareKey(JSON.stringify(a.geometry), JSON.stringify(b.geometry))).filter((item, index, sorted) => item.key !== sorted[index - 1]?.key);
+}
+
+//#endregion
+//#region ../core/src/map-drawing/labels.ts
+/**
+* Collision budget for a ~12.5-unit label in an ordinary sans-serif, with room for a heavier site font.
+* Renderers can set label type smaller than this, never larger.
+*/
+const CHARACTER_WIDTH = 7;
+const HALF_HEIGHT = 8;
+const PADDING = 5;
+/** How far a street may bend away from the straight line its label is written along. */
+const MAX_BEND = 4.5;
+/** Preferred places along a street for its label, as fractions of its visible length. */
+const POSITIONS = [
+	.5,
+	.4,
+	.6,
+	.3,
+	.7,
+	.2,
+	.8,
+	.1,
+	.9
+];
+/** Street pieces whose ends are this close are one street (OSM ways and tile clipping both split streets). */
+const JOIN_DISTANCE = 1;
+/**
+* Every label lies wholly inside the central 400 × 300 units. Renderers always show at least that much (a phone
+* at 0.85 px per unit or more, a 1200 × 500 band at 1.5), so a crop never cuts a street name in half.
+*/
+const LABEL_WINDOW = {
+	left: 200,
+	right: 600,
+	top: 250,
+	bottom: 550
+};
+/** The pin is a teardrop 26 units wide and 38 tall with its tip on the point; labels keep clear of it. */
+const PIN_KEEP_OUT = {
+	left: 382,
+	right: 418,
+	top: 358,
+	bottom: 406
+};
+const LABELLED_ROLES = ["major", "minor"];
+const textLength = (text) => Array.from(text).length * CHARACTER_WIDTH;
+/** The label's rotated rectangle, which collision checks treat as solid. */
+function corners(label$1) {
+	const radians = label$1.angle * Math.PI / 180, cos = Math.cos(radians), sin = Math.sin(radians);
+	const half = textLength(label$1.text) / 2 + PADDING;
+	const at = (x, y) => [label$1.point[0] + x * cos - y * sin, label$1.point[1] + x * sin + y * cos];
+	return [
+		at(-half, -HALF_HEIGHT),
+		at(half, -HALF_HEIGHT),
+		at(half, HALF_HEIGHT),
+		at(-half, HALF_HEIGHT)
+	];
+}
+const boxCorners = (box) => [
+	[box.left, box.top],
+	[box.right, box.top],
+	[box.right, box.bottom],
+	[box.left, box.bottom]
+];
+/** The label's axis-aligned extent once rotated. */
+function labelBounds(label$1) {
+	const points = corners(label$1), xs = points.map((point$1) => point$1[0]), ys = points.map((point$1) => point$1[1]);
+	return {
+		left: Math.min(...xs),
+		right: Math.max(...xs),
+		top: Math.min(...ys),
+		bottom: Math.max(...ys)
+	};
+}
+function overlaps(a, b) {
+	return a.left <= b.right && a.right >= b.left && a.top <= b.bottom && a.bottom >= b.top;
+}
+/** Separating-axis test for two rectangles; diagonal labels would block far too much as bounding boxes. */
+function rectanglesMeet(a, b) {
+	const axes = [a, b].flatMap((box) => [[box[1][0] - box[0][0], box[1][1] - box[0][1]], [box[3][0] - box[0][0], box[3][1] - box[0][1]]]);
+	return axes.every(([x, y]) => {
+		const project = (box) => box.map((point$1) => point$1[0] * x + point$1[1] * y);
+		const first = project(a), second = project(b);
+		return Math.max(...first) >= Math.min(...second) && Math.max(...second) >= Math.min(...first);
+	});
+}
+function labelsCollide(a, b) {
+	return rectanglesMeet(corners(a), corners(b));
+}
+function labelCoversPin(label$1) {
+	return rectanglesMeet(corners(label$1), boxCorners(PIN_KEEP_OUT));
+}
+const inside = (inner, outer) => inner.left >= outer.left && inner.right <= outer.right && inner.top >= outer.top && inner.bottom <= outer.bottom;
+function pointAlong(points, at) {
+	return segments(points).reduce((state, { start, end }) => {
+		if (state.point !== null) return state;
+		const size = distance(start, end);
+		if (size === 0 || state.remaining > size) return {
+			remaining: state.remaining - size,
+			point: null
+		};
+		const fraction = state.remaining / size;
+		return {
+			remaining: 0,
+			point: [start[0] + (end[0] - start[0]) * fraction, start[1] + (end[1] - start[1]) * fraction]
+		};
+	}, {
+		remaining: at,
+		point: null
+	}).point;
+}
+/** The run of street a label of `size` would cover around `centre`, with the vertices inside it. */
+function stretch(points, centre, size) {
+	const start = pointAlong(points, centre - size / 2), end = pointAlong(points, centre + size / 2), middle = pointAlong(points, centre);
+	if (start === null || end === null || middle === null) return null;
+	const offsets = points.reduce((sums, point$1, index) => [...sums, index === 0 ? 0 : (sums[index - 1] ?? 0) + distance(points[index - 1] ?? point$1, point$1)], []);
+	return {
+		start,
+		end,
+		middle,
+		vertices: points.filter((_, index) => Math.abs((offsets[index] ?? 0) - centre) < size / 2)
+	};
+}
+function uprightAngle(start, end) {
+	const degrees = Math.atan2(end[1] - start[1], end[0] - start[0]) * 180 / Math.PI;
+	const upright = degrees > 90 ? degrees - 180 : degrees <= -90 ? degrees + 180 : degrees;
+	return Math.round(upright * 10) / 10 || 0;
+}
+/** Joins `line` onto `chain` when one end of each meets, keeping the chain's direction where it can. */
+function join(chain, line$1) {
+	const meets = (a, b) => a !== undefined && b !== undefined && distance(a, b) <= JOIN_DISTANCE;
+	const reversed = line$1.slice().reverse();
+	if (meets(chain[chain.length - 1], line$1[0])) return [...chain, ...line$1.slice(1)];
+	if (meets(chain[chain.length - 1], reversed[0])) return [...chain, ...reversed.slice(1)];
+	if (meets(line$1[line$1.length - 1], chain[0])) return [...line$1, ...chain.slice(1)];
+	return meets(reversed[reversed.length - 1], chain[0]) ? [...reversed, ...chain.slice(1)] : null;
+}
+function stitchPass(streets) {
+	return streets.reduce((chains, street) => {
+		const index = chains.findIndex((chain$1) => chain$1.name === street.name && chain$1.major === street.major && join(chain$1.points, street.points) !== null);
+		const chain = chains[index];
+		const joined = chain === undefined ? null : join(chain.points, street.points);
+		return chain === undefined || joined === null ? [...chains, street] : chains.map((item, at) => at === index ? {
+			...item,
+			distance: Math.min(item.distance, street.distance),
+			points: joined
+		} : item);
+	}, []);
+}
+/** Whole named streets from their pieces, so a name is written along the street rather than one short way of it. */
+function stitch(streets) {
+	const next = stitchPass(streets);
+	return next.length === streets.length ? next : stitch(next);
+}
+function namedStreets(roads) {
+	return roads.slice().sort((a, b) => compareKey(a.key, b.key)).flatMap(({ geometry, distance: distance$1 }) => geometry.kind === "road" && geometry.name !== null && LABELLED_ROLES.includes(geometry.role) ? [{
+		name: geometry.name,
+		major: geometry.role === "major",
+		distance: distance$1,
+		points: geometry.points
+	}] : []);
+}
+/** Label options for one street, best first: only where the street runs straight enough to write along. */
+function streetLabels({ name: text, points }) {
+	const size = textLength(text);
+	const length = segments(points).reduce((sum, { start, end }) => sum + distance(start, end), 0);
+	if (length < size) return [];
+	return POSITIONS.flatMap((position) => {
+		const centre = Math.min(Math.max(length * position, size / 2), length - size / 2);
+		const run = stretch(points, centre, size);
+		if (run === null || run.vertices.some((vertex) => deviation(vertex, run.start, run.end) > MAX_BEND)) return [];
+		return [{
+			className: "map-label",
+			haloClassName: "map-label-halo",
+			text,
+			point: roundPoint(run.middle),
+			angle: uprightAngle(run.start, run.end)
+		}];
+	});
+}
+function fits(label$1, placed) {
+	return inside(labelBounds(label$1), LABEL_WINDOW) && !labelCoversPin(label$1) && placed.every((other) => other.text !== label$1.text && !labelsCollide(label$1, other));
+}
+/** Nearest streets first, as the framing weighs them: the ones around the door are the names a visitor needs. */
+function placeLabels(roads, framing) {
+	const { maxLabels, minorLabelDistance } = framing;
+	const weighted = (street) => street.major ? street.distance : street.distance * minorLabelDistance;
+	return stitch(namedStreets(roads)).slice().sort((a, b) => weighted(a) - weighted(b) || compareKey(a.name, b.name)).reduce((placed, street) => {
+		if (placed.length >= maxLabels) return placed;
+		const label$1 = streetLabels(street).find((option) => fits(option, placed));
+		return label$1 === undefined ? placed : [...placed, label$1];
+	}, []);
+}
+
+//#endregion
+//#region ../core/src/map-drawing/coverage.ts
+/** The bounded mixed-zoom coverage decision shared by extraction and completeness validation. */
+function drawingTileCoverage(pin) {
+	const contexts = FRAMINGS.map((framing) => ({
+		framing,
+		projection: createProjection(pin, framing.radiusMeters)
+	}));
+	if (contexts.some(({ projection }) => !supportsProjection(pin, projection))) return err("unsupported-latitude");
+	const bounds = contexts.map(({ framing, projection }) => {
+		const n = 2 ** framing.zoom;
+		const left = Math.floor((projection.center[0] - projection.span / 2) * n), right = Math.floor((projection.center[0] + projection.span / 2) * n);
+		const top = Math.floor((projection.center[1] - projection.span / 2) * n), bottom = Math.floor((projection.center[1] + projection.span / 2) * n);
+		return {
+			z: framing.zoom,
+			n,
+			left,
+			top,
+			bottom,
+			width: right - left + 1,
+			count: (right - left + 1) * (bottom - top + 1)
+		};
+	});
+	if (bounds.some((value) => !Number.isFinite(value.count) || value.count < 1 || value.top < 0 || value.bottom >= value.n) || bounds.reduce((sum, value) => sum + value.count, 0) > 96) return err("geometry-limit");
+	return ok(bounds.flatMap(({ z: z$1, n, left, top, width, count }) => Array.from({ length: count }, (_, index) => ({
+		z: z$1,
+		x: ((left + index % width) % n + n) % n,
+		y: top + Math.floor(index / width)
+	}))));
+}
+
+//#endregion
+//#region ../core/src/map-drawing/generate.ts
+const ROLE_ORDER = [
+	"major",
+	"minor",
+	"path"
+];
+const MAX_BUILDINGS = 1e3;
+const MAX_ROADS = 300;
+/** What this framing draws: its road roles, buildings or not, and no green patches too small to read. */
+function belongsIn(framing, item) {
+	const geometry = item.geometry;
+	if (geometry.kind === "road") return framing.roads.some((role) => role === geometry.role) && (geometry.role !== "path" || item.distance <= framing.maxPathDistance);
+	if (geometry.className === "map-building") return framing.buildings;
+	return geometry.className !== "map-park" || geometry.rings.some((ring) => polygonArea(ring) >= framing.minParkArea);
+}
+function selectFeatures(framing, candidates) {
+	const ordered = candidates.filter((item) => belongsIn(framing, item)).sort((a, b) => a.distance - b.distance || a.rank - b.rank || compareKey(a.key, b.key));
+	const buildings = ordered.filter((item) => item.geometry.kind === "polygon" && item.geometry.className === "map-building").slice(0, MAX_BUILDINGS);
+	const roleOrder = (item) => item.geometry.kind === "road" ? ROLE_ORDER.indexOf(item.geometry.role) : 0;
+	const roads = ordered.filter((item) => item.geometry.kind === "road").sort((a, b) => roleOrder(a) - roleOrder(b) || a.distance - b.distance || compareKey(a.key, b.key)).slice(0, MAX_ROADS);
+	const ground = ordered.filter((item) => item.geometry.kind === "polygon" && item.geometry.className !== "map-building");
+	return [
+		...ground,
+		...buildings,
+		...roads
+	];
+}
+/** Water over green, so a wood or park running to the bank never hides the river. */
+const POLYGON_ORDER = [
+	"map-land",
+	"map-park",
+	"map-water",
+	"map-building"
+];
+function paintingOrder(candidate$1) {
+	const geometry = candidate$1.geometry;
+	return geometry.kind === "road" ? POLYGON_ORDER.length + ROLE_ORDER.length - ROLE_ORDER.indexOf(geometry.role) : POLYGON_ORDER.indexOf(geometry.className);
+}
+const casingClass = {
+	major: "map-road-major-casing",
+	minor: "map-road-minor-casing"
+};
+const strokeClass = {
+	major: "map-road-major",
+	minor: "map-road-minor",
+	path: "map-road-path"
+};
+/** Casings under every stroke; paths are a single thin line with no casing. */
+function roadPaths(roads) {
+	const lines = roads.flatMap((item) => item.geometry.kind === "road" ? [item.geometry] : []);
+	const casings = lines.flatMap(({ role, points }) => role === "path" ? [] : [{
+		kind: "line",
+		className: casingClass[role],
+		points
+	}]);
+	return [...casings, ...lines.map(({ role, points }) => ({
+		kind: "line",
+		className: strokeClass[role],
+		points
+	}))];
+}
+function generateFrame(input, framing, projection) {
+	const candidates = input.tiles.filter((tile$1) => tile$1.z === framing.zoom).flatMap((tile$1) => tile$1.features.flatMap((feature$1) => projectFeature(tile$1, feature$1, projection)));
+	const selected = selectFeatures(framing, deduplicate(candidates)).slice().sort((a, b) => paintingOrder(a) - paintingOrder(b) || a.rank - b.rank || compareKey(a.key, b.key));
+	const polygons = selected.flatMap((item) => item.geometry.kind === "polygon" ? [item.geometry] : []);
+	const roads = selected.filter((item) => item.geometry.kind === "road");
+	return {
+		radiusMeters: framing.radiusMeters,
+		viewBox: [
+			0,
+			0,
+			800,
+			800
+		],
+		backgroundClass: "map-water",
+		paths: [...polygons, ...roadPaths(roads)],
+		labels: placeLabels(roads, framing),
+		pin: {
+			className: "map-pin",
+			point: [400, 400]
+		}
+	};
+}
+/** Pure: parse decoded input once, decide both framings, return only closed numeric geometry. */
+function generateMapDrawing(raw) {
+	const parsed = mapDrawingInputSchema.safeParse(raw);
+	if (!parsed.success) return err("invalid-input");
+	const input = parsed.data;
+	const coverage = drawingTileCoverage(input.pin);
+	if (!coverage.ok) return err(coverage.error);
+	const neighbourhood = {
+		framing: FRAMINGS[0],
+		projection: createProjection(input.pin, FRAMINGS[0].radiusMeters)
+	};
+	const wider = {
+		framing: FRAMINGS[1],
+		projection: createProjection(input.pin, FRAMINGS[1].radiusMeters)
+	};
+	const keys = input.tiles.map((tile$1) => `${tile$1.z}/${tile$1.x}/${tile$1.y}`);
+	const present = new Set(keys);
+	if (present.size !== keys.length) return err("invalid-input");
+	if (coverage.value.some((tile$1) => !present.has(`${tile$1.z}/${tile$1.x}/${tile$1.y}`))) return err("missing-tiles");
+	const drawing = mapDrawingSchema.safeParse({
+		schemaVersion: DRAWING_SCHEMA_VERSION,
+		generatorVersion: DRAWING_GENERATOR_VERSION,
+		buildId: input.buildId,
+		tileSchemaVersion: input.tileSchemaVersion,
+		frames: {
+			neighbourhood: generateFrame(input, neighbourhood.framing, neighbourhood.projection),
+			wider: generateFrame(input, wider.framing, wider.projection)
+		}
+	});
+	if (!drawing.success) return err("geometry-limit");
+	return ok(drawing.data);
+}
+
 //#endregion
 //#region ../core/src/authored-values.ts
 /** Canonical authored equality: empty storage values and absent optional members agree. */
@@ -8855,4 +9814,4 @@ function isPlainRecord(value) {
 }
 
 //#endregion
-export { inferSiteDateLocale as $, parseCurrencyCode as $t, assessMailingListTargeting as A, unsafeAsPositiveByteCount as An, resolveFlexibleBalanceInitialPaymentCents as At, parsePublicContactDetails as B, unsafeAsStoragePath as Bn, resolveExactOrFreePriceDisplay as Bt, parseManagementKey as C, unsafeAsEventOfferingId as Cn, clampConfiguredAmount as Ct, parseMailingListContentVersionId as D, unsafeAsOccurrenceId as Dn, omitZeroAmountFutureRows as Dt, parseMailingListBlockId as E, unsafeAsMediaAssetId as En, getBookingInstalmentProtectedDepositAmountCents as Et, parseMailingListPlacementTargeting as F, unsafeAsSiteFontId as Fn, isPublicEventPricingOptionDisplayable as Ft, isPresent as G, isNonNegativeWholeCents as Gt, assertAllowedPublicUrl as H, unsafeAsUserId as Hn, fromArray as Ht, DEFAULT_MAILING_LIST_TARGETING as I, unsafeAsSiteId as In, publicEventPricingCurrency as It, formatDateRange as J, toCents as Jt, selectCategoryView as K, parseNonNegativeCents as Kt, planMailingListChoicePresentation as L, unsafeAsSiteScopedStoragePath as Ln, publicEventPricingDisplay as Lt, parseMailingListProviderScope as M, unsafeAsPricingOptionId as Mn, parseEventPageSurfaceSubject as Mt, parseFooterCompositionV1 as N, unsafeAsProductId as Nn, formatBookingPriceDisplay as Nt, parseMailingListSignedSourceToken as O, unsafeAsOriginalFilename as On, splitAmountWithRemainderInFirst as Ot, footerNavigationLayouts as P, unsafeAsSafeDownloadFilename as Pn, formatEventPricing as Pt, formatTimeRange as Q, formatCurrencyAmount as Qt, isCanonicalRichTextDoc as R, unsafeAsStaffMemberId as Rn, publicEventPricingOptions as Rt, exposeSecret as S, unsafeAsEventInstanceId as Sn, addIntervalPreservingMonthAnchor as St, slugify as T, unsafeAsFileChecksumSha256 as Tn, getBookingInstalmentPlanIntervalCount as Tt, normalizeLocationAddressText as U, err as Un, mapNonEmptyArray as Ut, parseWeeklyOpeningHours as V, unsafeAsUploadSessionId as Vn, resolvePricingOptionsPriceDisplay as Vt, toLocationCoordinates as W, ok as Wn, mapReadonlyNonEmptyArray as Wt, formatDateTimeRange as X, unsafeAsNonNegativeCents as Xt, formatDateTime as Y, toNonNegativeCents as Yt, formatTime as Z, unsafeAsPositiveCents as Zt, nextLiveRunSessionStartMs as _, unsafeAsCheckoutLineId as _n, parseBookingTimeZone as _t, areConfiguredBookingVerticalConfigsEqual as a, parseDatedOfferingCapacityHoldId as an, getBookingLocalDateKey as at, resolveWholeSeriesRunLifecycle as b, unsafeAsDetectedMimeType as bn, isSettleableFlexibleBalanceContractStatus as bt, parseVerticalPresetId as c, parseMembershipId as cn, localScheduleTimePattern as ct, EVENT_PRESET_VALUES as d, parseSiteId as dn, parseUtcIsoDateTimeString as dt, assertNever as en, resolveBookingDisplayContext as et, ORDINARY_EVENT_PRESET_VALUES as f, parseSiteTermsVersionId as fn, resolveBookingBusinessTimeZone as ft, CANCELLED_SESSION_STATUS as g, unsafeAsBookingSessionId as gn, toUtcIsoDateTimeString as gt, publicReadFreshnessSeconds as h, unsafeAsBookingRequirementId as hn, toScheduledBookingDateTime as ht, NAVIGATION_LOCATIONS as i, parseDatedOfferingCapacityHoldAuditRef as in, formatLocalScheduleTime as it, DEFAULT_MAILING_LIST_SUCCESS_MESSAGE as j, unsafeAsPositiveSeconds as jn, deriveTotalTicketQuantity as jt, parseMailingListRuntimeContext as k, unsafeAsPassId as kn, resolveFlexibleBalanceDueAt as kt, resolveSiteVerticalBookingConfig as l, parsePageId as ln, parseBookingLocalDate as lt, WHOLE_SERIES_EVENT_PRESET_VALUES as m, unsafeAsAppointmentResourceId as mn, toBookingTimeZone as mt, resolveEventCatalogue as n, parseApiKeyId as nn, compareLocalScheduleDates as nt, canonicalizeConfiguredBookingVerticalConfig as o, parseEventSeriesId as on, getLocalScheduleDate as ot, SURFACE_EVENT_PRESET_VALUES as p, parseUserId as pn, resolveBookingTimeZoneId as pt, formatDate as q, parsePositiveCents as qt, EVENT_PRESET_VOCABULARY as r, parseCustomerId as rn, formatLocalScheduleDate as rt, parseVerticalId as s, parseMediaAssetId as sn, getLocalScheduleTime as st, authoredValuesEqual as t, formatDurationUnitLabel as tn, buildBookingUtcDateWindow as tt, DEFAULT_EVENT_TYPE_PRESETS as u, parseRetiredCourseId as un, parseLocalScheduleTime as ut, orderedLiveRunSessions as v, unsafeAsDeclaredMimeType as vn, validateBookingPaymentOptionKinds as vt, stableJsonStringify as w, unsafeAsEventSeriesId as wn, getBookingInstalmentDepositRefundability as wt, createSecret as x, unsafeAsEntitlementId as xn, isSettleableOrderInstalmentPlanStatus as xt, resolveWholeSeriesBookingPhase as y, unsafeAsDemoCapability as yn, isLiveOrderInstalmentPlanStatus as yt, formatOpeningHoursRows as z, unsafeAsStorageBucketName as zn, publicEventPricingType as zt };
+export { selectCategoryView as $, parseNonNegativeCents as $t, DEFAULT_MAILING_LIST_SUCCESS_MESSAGE as A, unsafeAsEventOfferingId as An, clampConfiguredAmount as At, parseWeeklyOpeningHours as B, unsafeAsProductId as Bn, formatBookingPriceDisplay as Bt, parseManagementKey as C, unsafeAsBookingSessionId as Cn, toUtcIsoDateTimeString as Ct, parseMailingListSignedSourceToken as D, unsafeAsDetectedMimeType as Dn, isSettleableFlexibleBalanceContractStatus as Dt, parseMailingListContentVersionId as E, unsafeAsDemoCapability as En, isLiveOrderInstalmentPlanStatus as Et, DEFAULT_MAILING_LIST_TARGETING as F, unsafeAsOriginalFilename as Fn, splitAmountWithRemainderInFirst as Ft, locationValueSchema as G, unsafeAsStaffMemberId as Gn, publicEventPricingOptions as Gt, decideLocationSave as H, unsafeAsSiteFontId as Hn, isPublicEventPricingOptionDisplayable as Ht, planMailingListChoicePresentation as I, unsafeAsPassId as In, resolveFlexibleBalanceDueAt as It, projectPublicLocation as J, unsafeAsUploadSessionId as Jn, resolvePricingOptionsPriceDisplay as Jt, normalizeLocationAddressText as K, unsafeAsStorageBucketName as Kn, publicEventPricingType as Kt, isCanonicalRichTextDoc as L, unsafeAsPositiveByteCount as Ln, resolveFlexibleBalanceInitialPaymentCents as Lt, parseFooterCompositionV1 as M, unsafeAsFileChecksumSha256 as Mn, getBookingInstalmentPlanIntervalCount as Mt, footerNavigationLayouts as N, unsafeAsMediaAssetId as Nn, getBookingInstalmentProtectedDepositAmountCents as Nt, parseMailingListRuntimeContext as O, unsafeAsEntitlementId as On, isSettleableOrderInstalmentPlanStatus as Ot, parseMailingListPlacementTargeting as P, unsafeAsOccurrenceId as Pn, omitZeroAmountFutureRows as Pt, mapDrawingSchema as Q, isNonNegativeWholeCents as Qt, formatOpeningHoursRows as R, unsafeAsPositiveSeconds as Rn, deriveTotalTicketQuantity as Rt, exposeSecret as S, unsafeAsBookingRequirementId as Sn, toScheduledBookingDateTime as St, parseMailingListBlockId as T, unsafeAsDeclaredMimeType as Tn, validateBookingPaymentOptionKinds as Tt, stableJsonStringify as U, unsafeAsSiteId as Un, publicEventPricingCurrency as Ut, assertAllowedPublicUrl as V, unsafeAsSafeDownloadFilename as Vn, formatEventPricing as Vt, locationMapLinks as W, unsafeAsSiteScopedStoragePath as Wn, publicEventPricingDisplay as Wt, toLocationCoordinates as X, err as Xn, mapNonEmptyArray as Xt, publicLocationSchema as Y, unsafeAsUserId as Yn, fromArray as Yt, isPresent as Z, ok as Zn, mapReadonlyNonEmptyArray as Zt, nextLiveRunSessionStartMs as _, parseRetiredCourseId as _n, parseLocalScheduleTime as _t, areConfiguredBookingVerticalConfigsEqual as a, formatCurrencyAmount as an, formatTimeRange as at, resolveWholeSeriesRunLifecycle as b, parseUserId as bn, resolveBookingTimeZoneId as bt, parseVerticalPresetId as c, formatDurationUnitLabel as cn, buildBookingUtcDateWindow as ct, EVENT_PRESET_VALUES as d, parseDatedOfferingCapacityHoldAuditRef as dn, formatLocalScheduleTime as dt, parsePositiveCents as en, formatDate as et, ORDINARY_EVENT_PRESET_VALUES as f, parseDatedOfferingCapacityHoldId as fn, getBookingLocalDateKey as ft, CANCELLED_SESSION_STATUS as g, parsePageId as gn, parseBookingLocalDate as gt, publicReadFreshnessSeconds as h, parseMembershipId as hn, localScheduleTimePattern as ht, NAVIGATION_LOCATIONS as i, unsafeAsPositiveCents as in, formatTime as it, parseMailingListProviderScope as j, unsafeAsEventSeriesId as jn, getBookingInstalmentDepositRefundability as jt, assessMailingListTargeting as k, unsafeAsEventInstanceId as kn, addIntervalPreservingMonthAnchor as kt, resolveSiteVerticalBookingConfig as l, parseApiKeyId as ln, compareLocalScheduleDates as lt, WHOLE_SERIES_EVENT_PRESET_VALUES as m, parseMediaAssetId as mn, getLocalScheduleTime as mt, resolveEventCatalogue as n, toNonNegativeCents as nn, formatDateTime as nt, canonicalizeConfiguredBookingVerticalConfig as o, parseCurrencyCode as on, inferSiteDateLocale as ot, SURFACE_EVENT_PRESET_VALUES as p, parseEventSeriesId as pn, getLocalScheduleDate as pt, parseLocationValue as q, unsafeAsStoragePath as qn, resolveExactOrFreePriceDisplay as qt, EVENT_PRESET_VOCABULARY as r, unsafeAsNonNegativeCents as rn, formatDateTimeRange as rt, parseVerticalId as s, assertNever as sn, resolveBookingDisplayContext as st, authoredValuesEqual as t, toCents as tn, formatDateRange as tt, DEFAULT_EVENT_TYPE_PRESETS as u, parseCustomerId as un, formatLocalScheduleDate as ut, orderedLiveRunSessions as v, parseSiteId as vn, parseUtcIsoDateTimeString as vt, slugify as w, unsafeAsCheckoutLineId as wn, parseBookingTimeZone as wt, createSecret as x, unsafeAsAppointmentResourceId as xn, toBookingTimeZone as xt, resolveWholeSeriesBookingPhase as y, parseSiteTermsVersionId as yn, resolveBookingBusinessTimeZone as yt, parsePublicContactDetails as z, unsafeAsPricingOptionId as zn, parseEventPageSurfaceSubject as zt };