@medalsocial/booking 0.0.0-placeholder.0 → 0.1.0

package/dist/core/machine.mjs

@@ -0,0 +1,878 @@
+import { isChildCategory } from "./categories.mjs";
+import { fill, labelText, resolveLabels } from "./labels.mjs";
+import { createClock } from "./clock.mjs";
+import { resourceMatches } from "./deep-link.mjs";
+import { createMoney } from "./money.mjs";
+//#region src/core/machine.ts
+/**
+* The wizard's brain: which step is reachable, what the sticky summary bar
+* says, and when submit is allowed. All of it lives here and nowhere else.
+*
+* Deliberately pure — no React, no fetch, no DOM — so every rule is testable
+* without rendering. `medal-client.ts` is `server-only` and must never be
+* imported from this file; the wizard runs in the browser.
+*
+* The step components (meda's `/booking` screens) are meant to be
+* presentational. If one of them would need an `if` about wizard state, that
+* `if` belongs here instead.
+*
+* Most of the machine is config-free and exported as is. `createWizard(config)`
+* binds the parts that are not: the party ceiling (`party.maxPeople`), which
+* category is the kids' path (`categories[].audience`), the weekend on the
+* business's clock, the currency, and the words the summary line uses.
+*/
+/** The logged-in parent themselves, on step 1's «Meg selv (voksen)». */
+const SELF_KEY = "self";
+/**
+* A seat only a GUEST's step 1 can draw: a count chip's `guest:n`, a child
+* named in the guest sheet (`new:…`), the «Voksen» chip's `adult`. A parent's
+* step 1 draws cards for saved children and «Meg selv» and nothing else — so
+* one of these under a family is a seat nobody can see or untick, counting
+* towards the three.
+*/
+function isGuestSeat(person) {
+	return person.key.startsWith("guest:") || person.key.startsWith("new:") || person.key === "adult";
+}
+/**
+* The engine's own bound on `booked_for_name` — `maxLength: 200` in the SDK's
+* OpenAPI document. Step 4's input has no `maxLength`, so this is the one limit
+* that exists, and a prefilled name is cut to it rather than being carried into
+* a body the engine answers 400 to.
+*/
+const BOOKED_FOR_NAME_MAX_LENGTH = 200;
+const SEPARATOR = " · ";
+/** Stands in for a part the visitor has not chosen yet, so the bar keeps its
+* shape as they fill it in rather than growing under their thumb. */
+const UNCHOSEN = "—";
+function initialState() {
+	return {
+		step: "who",
+		people: [],
+		choices: [],
+		items: [],
+		resourceId: null,
+		stylistAnswered: false,
+		partyMode: "sequential",
+		startTs: null,
+		resolvedResourceId: null,
+		partyResourceIds: null,
+		contact: {
+			phone: "",
+			name: "",
+			email: ""
+		},
+		notes: "",
+		consentTerms: false,
+		consentMarketing: false,
+		pendingService: null,
+		error: null
+	};
+}
+/**
+* The strictest service involved sets the party limit — and the service about to
+* be added counts, not just the ones already chosen. Mirroring the engine rather
+* than inventing a ceiling: `bookings.ts` takes `Math.min` over every service in
+* the request and imposes no cap of its own, so the salon's real ceiling is
+* whatever it seeded (`maxPerBooking: 3` for `barn`, 1 for everything else). A
+* hardcoded number here would be a second, invisible rule that silently
+* disagreed with the salon's the day they changed it.
+*
+* Counting the incoming service is what lets a strict one refuse at the tap
+* instead of at submit — the engine's own worked example is that a service with
+* `maxPerBooking: 1` cannot ride along in a party of four. It also disposes of
+* `Math.min()`-of-nothing: the spread always holds at least the incoming
+* service, so an empty basket yields that service's own limit rather than
+* `Infinity`, and `addService` cannot append forever.
+*/
+function partyLimit(items, incoming) {
+	return Math.min(incoming.maxPerBooking, ...items.map((item) => item.service.maxPerBooking));
+}
+/** The one stylist a seating chart names throughout, or `null` when it names
+* more than one. An empty chart has nobody, which is also `null`. */
+function sharedResourceId(resourceIds) {
+	const [first] = resourceIds;
+	if (first === void 0) return null;
+	return resourceIds.every((id) => id === first) ? first : null;
+}
+/**
+* What `addService` does to the stylist preference: nothing, or release it.
+*
+* A patch rather than a boolean, so the case below spreads one expression and
+* says what it means — and so the empty object is the ordinary answer, which is
+* the point: adding a sibling is not a change of mind about Sara.
+*
+* `resourceServiceIds` absent is «the caller could not say», and it keeps the
+* preference. That direction is deliberate: a wizard whose stylist catalogue has
+* not loaded knows nothing about who does what, and discarding an answer the
+* visitor gave on the strength of that would be a guess dressed as a safeguard.
+* The catalogue is loaded by the time a stylist can be tapped at all, so the
+* case is a caller other than the wizard rather than a race.
+*/
+function stylistAfterAdd(action) {
+	return action.resourceServiceIds === void 0 || action.resourceServiceIds.includes(action.service.id) ? {} : {
+		resourceId: null,
+		stylistAnswered: false
+	};
+}
+/**
+* A chosen slot belongs to the question it was chosen under, so every action
+* that changes that question has to drop it — the basket, the seating mode, and
+* the stylist alike. Adding a second child doubles the duration being asked for;
+* swapping the service changes it outright; naming a different stylist points it
+* at somebody else's diary. Either way the time the visitor tapped is no longer
+* a time the salon ever offered them.
+*
+* Left in place this stays invisible until the progress dots become tappable,
+* and then it is a genuinely bad bug rather than an untidy one: `canGoToStep`
+* treats any non-null `startTs` as reason enough to reach `details`, so going
+* back, changing an answer and jumping straight forward submits against a slot
+* that answered the old question — with the summary bar quoting the stale time
+* as if it were confirmed.
+*
+* This spread deliberately does NOT touch `resourceId`, because that is a
+* separate answer and each caller has its own view of it:
+*
+* - `pickResource` writes it — it *is* the new answer.
+* - `pickService` clears it, because the basket was replaced and step 2 only
+*   offers stylists who can do every service in it.
+* - `setPartyMode` clears it for `parallel`, which is two stylists by
+*   construction.
+* - `addService` keeps it, unless the child being added is one the named stylist
+*   cannot take. A parent adding a sibling has not changed their mind about
+*   Sara, so clearing unconditionally would re-ask every family in the common
+*   case where she can do both — but keeping it unconditionally left step 2 with
+*   nothing selected and step 3 filtered to somebody who cannot take the visit,
+*   which is «Fullt» on every day of the week at a salon with a free chair.
+*   The catalogue that tells the two apart is a fetch result the shell holds and
+*   this file cannot reach, so it arrives on the action as
+*   `resourceServiceIds`; absent, the preference is kept.
+*
+* `partyResourceIds` is the other half of a chosen slot and goes with it. Left
+* behind it would be a seating chart for a party that no longer has that many
+* children in it, and `itemResourceIds` would hand the submission a stylist for
+* a line item that does not exist.
+*/
+const clearedSlot = {
+	startTs: null,
+	resolvedResourceId: null,
+	partyResourceIds: null
+};
+/** The guest child in chair `n` (1-based) — a chip on step 1, or a sibling a link added. */
+function guestChild(n) {
+	return { key: `guest:${n}` };
+}
+/** A person as a line item: the service, and what is known about who sits in the chair. */
+function itemFor(person, service) {
+	return {
+		service,
+		...person.name === void 0 ? {} : { bookedForName: person.name },
+		...person.birthYear === void 0 ? {} : { bookedForBirthYear: person.birthYear },
+		...person.personId === void 0 ? {} : { bookedForPersonId: person.personId },
+		...person.birthMonth === void 0 ? {} : { bookedForBirthMonth: person.birthMonth },
+		...person.adult ? { adult: true } : {}
+	};
+}
+function basketOf(items) {
+	return items.map((item) => item.service.id).join("|");
+}
+/**
+* `people` and `choices` in, the basket out — the one place `items` is built
+* from them. A basket whose services changed drops the slot, for the reason
+* `clearedSlot` gives; one that only changed WHO (a name typed on «Bekreft»,
+* say) keeps it.
+*/
+function withParty(state, people, choices) {
+	const items = people.length > 0 && choices.every((choice) => choice !== null) ? people.map((person, index) => itemFor(person, choices[index])) : [];
+	const changed = basketOf(items) !== basketOf(state.items);
+	return {
+		...state,
+		people,
+		choices,
+		items,
+		...changed ? clearedSlot : {}
+	};
+}
+/** The people behind a basket built without step 1 — a link, a restored draft. */
+function peopleFor(state, count) {
+	return Array.from({ length: count }, (_, index) => state.people[index] ?? guestChild(index + 1));
+}
+/**
+* One field of one line item, written the way the engine will have to read it:
+* **absent**, never blank.
+*
+* `booked_for_name` is `z.string().trim().min(1).optional()` upstream, where
+* `''` is a 400 rather than a shrug, and `booked_for_birth_year` is
+* `z.number().optional()`, which refuses the `null` an emptied input serialises
+* to. Storing the emptiness here and coalescing it at the edge would hold
+* exactly until something other than the create route read these items — the
+* confirmation card already does, to write «Gutteklipp for Jonas» — so the
+* emptiness never gets in.
+*/
+function withItemField(item, action) {
+	const next = { ...item };
+	if (action.field === "bookedForPersonId") {
+		if (action.value !== null && action.value !== "") next.bookedForPersonId = action.value;
+		else delete next.bookedForPersonId;
+		return next;
+	}
+	if (action.field === "bookedForName") {
+		const trimmed = action.value.trim();
+		if (trimmed.length > 0) next.bookedForName = trimmed;
+		else delete next.bookedForName;
+		return next;
+	}
+	if (action.value !== null && Number.isFinite(action.value)) next.bookedForBirthYear = action.value;
+	else delete next.bookedForBirthYear;
+	return next;
+}
+/** The typed answers about a guest child, carried back onto their person. */
+function withPersonFields(person, item) {
+	const { name: _name, birthYear: _year, personId: _id, ...rest } = person;
+	return {
+		...rest,
+		...item.bookedForName === void 0 ? {} : { name: item.bookedForName },
+		...item.bookedForBirthYear === void 0 ? {} : { birthYear: item.bookedForBirthYear },
+		...item.bookedForPersonId === void 0 ? {} : { personId: item.bookedForPersonId }
+	};
+}
+/** `seatFamily` — see the action. */
+function seatFamily(state) {
+	if (state.step !== "who" && state.step !== "service") return state;
+	if (!state.people.some(isGuestSeat)) return state;
+	const people = [];
+	const choices = [];
+	state.people.forEach((person, index) => {
+		const seat = person.key === "adult" ? {
+			key: SELF_KEY,
+			adult: true
+		} : person;
+		if (isGuestSeat(seat) || people.some((other) => other.key === seat.key)) return;
+		people.push(seat);
+		choices.push(state.choices[index] ?? null);
+	});
+	return {
+		...withParty(state, people, choices),
+		step: people.length === 0 ? "who" : state.step,
+		error: null
+	};
+}
+/** `pickServiceFor` — see the action. */
+function pickServiceFor(state, action) {
+	if (!state.people[action.index] && !(action.index === 0 && state.people.length === 0)) return state;
+	if (state.people.length <= 1) return {
+		...withParty(state, [state.people[0] ?? guestChild(1)], [action.service]),
+		...clearedSlot,
+		resourceId: null,
+		stylistAnswered: false,
+		step: "when",
+		error: null
+	};
+	if (action.service.maxPerBooking < state.people.length) return {
+		...state,
+		error: "maxParty"
+	};
+	const choices = state.choices.map((choice, index) => index === action.index ? action.service : choice);
+	const canServe = action.resourceServiceIds === void 0 || action.resourceServiceIds.includes(action.service.id);
+	return {
+		...withParty(state, state.people, choices),
+		...canServe ? {} : {
+			resourceId: null,
+			stylistAnswered: false
+		},
+		error: null
+	};
+}
+/** The wizard in order. Both `canGoToStep` and the progress dots read the
+* sequence from here rather than restating it, so a fourth step cannot be added
+* to one of them and forgotten in the other. */
+const STEP_ORDER = [
+	"who",
+	"service",
+	"when",
+	"details"
+];
+/**
+* Whether a given step has been answered. One definition, asked two ways —
+* `canAdvance` asks it about the step the visitor is on, `canGoToStep` asks it
+* about the ones behind the step they want. Keeping it in a single function is
+* what stops "step 3 is done" from meaning one thing to the Neste button and
+* another to the progress dots.
+*/
+function isSatisfied(state, step) {
+	switch (step) {
+		case "who": return state.people.length > 0 || state.items.length > 0;
+		case "service": return state.items.length > 0;
+		case "when": return state.startTs !== null;
+		case "details": return state.contact.phone.trim().length > 0 && state.consentTerms;
+	}
+}
+/**
+* True when the visitor may leave the current step — and on `details`, when they
+* may submit at all. Answers about `state.step` only, so a Neste button can be
+* `disabled={!canAdvance(state)}` and nothing else.
+*/
+function canAdvance(state) {
+	return isSatisfied(state, state.step);
+}
+/**
+* True when a step may be jumped to directly — the predicate behind whether a
+* progress dot is tappable, and the guard `goToStep` applies to itself.
+*
+* Bounded by what is *behind* the target, never the target itself: reaching
+* `details` requires a service and a time, but obviously not the contact
+* details you are going there to type. Going back is therefore always allowed,
+* because nothing precedes `service` — which is the case that matters, since
+* back is what the dots are mostly for.
+*/
+function canGoToStep(state, step) {
+	const index = STEP_ORDER.indexOf(step);
+	if (index === -1) return false;
+	return STEP_ORDER.slice(0, index).every((prior) => isSatisfied(state, prior));
+}
+/**
+* When each child in the party sits down.
+*
+* `sequential` is the report's default and the ordinary case — one stylist,
+* «rett etter hverandre», so the second child starts when the first is
+* finished. `parallel` is two stylists at once, and every line starts together.
+*
+* The engine takes a `start_ts` per line item rather than one for the visit, so
+* somebody has to do this arithmetic, and it is a rule about the booking rather
+* than about a screen. Step 4 submits with it and the confirmation card reads
+* «15:00 Jonas / 15:30 Emma» off the same function, which is the only way those
+* two can be made to agree.
+*
+* Task 9 owns the slot SEARCH for a party; this is only the seating of a slot
+* already chosen.
+*/
+function itemStartTimes(items, startTs, partyMode) {
+	let offset = 0;
+	return items.map(({ service }, index) => {
+		if (partyMode === "sequential" && index > 0) {
+			const previous = items[index - 1].service;
+			offset += (previous.durationMinutes + previous.bufferAfterMinutes + service.bufferBeforeMinutes) * 6e4;
+		}
+		return startTs + offset;
+	});
+}
+/**
+* How long the family is in the salon — the number the summary bar quotes as
+* «60 min totalt» and the length of the .ics entry.
+*
+* The two modes are two different visits: `sequential` is one chair used twice,
+* so the minutes add up, while `parallel` is two chairs at once and the family
+* leaves when the *longest* cut finishes. Quoting the sum for a parallel party
+* would tell a parent to set aside an hour for a visit that takes half of one,
+* which is the whole reason «To frisører samtidig» is worth offering.
+*
+* `Math.max` seeded with 0 rather than spread over the durations alone:
+* `Math.max()` of nothing is `-Infinity`, and an empty basket is a visit of no
+* length rather than a negative one.
+*/
+function visitMinutes(items, partyMode) {
+	if (partyMode === "parallel") return Math.max(0, ...items.map(({ service }) => service.durationMinutes));
+	return items.reduce((total, { service }, index) => total + service.durationMinutes + (index === 0 ? 0 : items[index - 1].service.bufferAfterMinutes + service.bufferBeforeMinutes), 0);
+}
+/**
+* How much EARLIER a family has to start than a single first child would.
+*
+* The schedule endpoint answers for one service, so `lastStartTs` is «the last
+* start a Gutteklipp fits» — the last minute at which that service's prep,
+* duration and cleanup all land inside the day's window. A family needs its
+* whole chain to fit, so its own last start is earlier by exactly the part of
+* the chain that hangs off the end of the first child's busy span.
+*
+* NOT `visitMinutes - firstDuration`, which was the first attempt and is wrong
+* in a way that only shows on a mixed basket: `visitMinutes` deliberately
+* excludes the LAST child's cleanup — the family has left by then — so the
+* subtraction silently keeps the FIRST child's cleanup in place of the last
+* one's. Where the later service has the bigger `bufferAfterMinutes` the cutoff
+* comes out too late, which is the error in the direction that matters: it says
+* «Fullt» about an afternoon that is actually over.
+*
+* Sequential is the tail of the chain: every child after the first costs their
+* prep, their duration and their cleanup, and the first child's own cleanup is
+* already inside the number being adjusted. Parallel is one chair each, so what
+* has to fit is the LONGEST busy span rather than the sum.
+*/
+function visitTailMinutes(items, partyMode) {
+	const first = items[0]?.service;
+	if (first === void 0 || items.length < 2) return 0;
+	const busy = (service) => service.bufferBeforeMinutes + service.durationMinutes + service.bufferAfterMinutes;
+	if (partyMode === "parallel") return Math.max(0, Math.max(...items.map(({ service }) => busy(service))) - busy(first));
+	return items.slice(1).reduce((total, { service }) => total + service.bufferBeforeMinutes + service.durationMinutes + service.bufferAfterMinutes, 0);
+}
+/** When the family leaves. The same arithmetic as `visitMinutes`, which is why
+* it is that function and not a second copy of it: an .ics that ended before
+* `visitMinutes` said the visit did would tell a calendar the parent was free
+* while a child was still in the chair. */
+function visitEndTs(items, startTs, partyMode) {
+	return startTs + visitMinutes(items, partyMode) * 6e4;
+}
+/**
+* Whether step 2 asks how the party is seen.
+*
+* One child is not a party, and «Samme frisør, rett etter hverandre» is not a
+* choice when there is nobody to be after. The machine answers rather than the
+* component so that the picker and the search cannot disagree about when a
+* booking has become a family visit.
+*/
+function showsPartyMode(state) {
+	return state.items.length > 1;
+}
+/**
+* Who is cutting whose hair, one answer per line item.
+*
+* The single reader for both shapes the machine can be in: a party slot names a
+* stylist per child, and everything else has one answer for the whole visit —
+* including `null`, which is «Første ledige» still to be resolved by the engine.
+*
+* Step 4's submission and the confirmation card both read it, which is the only
+* way «hos Marcus» on the card can be guaranteed to be the `resource_id` that
+* was actually booked for that child.
+*/
+function itemResourceIds(state) {
+	return state.partyResourceIds ?? state.items.map(() => state.resolvedResourceId);
+}
+/**
+* The stylist, as a person rather than as a row id.
+*
+* The machine holds ids — that is what step 2 chose and what the availability
+* query filters on — so naming one takes the catalogue, which is a fetch result
+* and not a rule. Hence the resolver: the caller already has the stylists it
+* rendered on step 2, and an id it cannot name comes back `null` rather than
+* putting `res-7f3a…` under the visitor's thumb.
+*
+* `resolvedResourceId` wins where both are set, because it is who the visitor
+* actually got. That is also what fills this part in for «Første ledige», which
+* is a null preference and stays a dash until a slot resolves it to somebody.
+*/
+function stylistLabel(state, resolveStylistName) {
+	const resourceId = state.resolvedResourceId ?? state.resourceId;
+	return resourceId === null ? null : resolveStylistName(resourceId);
+}
+/** The machine for one site: its party ceiling, kids' categories, clock, currency and words. */
+function createWizard(config) {
+	const maxPeople = config.party.maxPeople;
+	const clock = createClock(config);
+	const money = createMoney(config);
+	const labels = resolveLabels(config.locale, config.labels);
+	/** `choosePeople` — see the action. */
+	function choosePeople(state, action) {
+		if (action.people.length > maxPeople) return {
+			...state,
+			error: "maxParty"
+		};
+		const before = (person) => state.people.findIndex((previous) => previous.key === person.key);
+		const choices = action.people.map((person, position) => {
+			const index = before(person);
+			if (index !== -1) return state.choices[index] ?? null;
+			return heldFor(state.pendingService, person) ?? action.services?.[position] ?? null;
+		});
+		return {
+			...withParty(state, action.people.map((person) => {
+				const index = before(person);
+				return index === -1 || person.personId !== void 0 ? person : {
+					...state.people[index],
+					...person
+				};
+			}), choices),
+			step: action.advance ? "service" : state.step,
+			error: null
+		};
+	}
+	/** The held link service, if it suits this person: kids' cuts for children only. */
+	function heldFor(service, person) {
+		if (service === null) return null;
+		return isChildCategory(config, service.category) === !person.adult ? service : null;
+	}
+	/** `addPerson` — see the action. */
+	function addPerson(state, person) {
+		if (state.people.some((other) => other.key === person.key)) return state;
+		if (state.people.length >= maxPeople) return {
+			...state,
+			error: "maxParty"
+		};
+		return choosePeople(state, {
+			type: "choosePeople",
+			people: [...state.people, person]
+		});
+	}
+	function reduce(state, action) {
+		switch (action.type) {
+			case "startOver": return initialState();
+			case "choosePeople": return choosePeople(state, action);
+			case "pickServiceFor": return pickServiceFor(state, action);
+			case "seatFamily": return seatFamily(state);
+			case "addPerson": return addPerson(state, action.person);
+			case "holdService": return {
+				...state,
+				pendingService: action.service
+			};
+			case "pickService": return {
+				...withParty(state, peopleFor(state, 1), [action.service]),
+				...clearedSlot,
+				resourceId: null,
+				stylistAnswered: false,
+				step: "when",
+				error: null
+			};
+			case "addService":
+				if (state.items.length >= partyLimit(state.items, action.service)) return {
+					...state,
+					error: "maxParty"
+				};
+				return {
+					...withParty(state, peopleFor(state, state.items.length + 1), [...state.items.map((item) => item.service), action.service]),
+					...clearedSlot,
+					...stylistAfterAdd(action),
+					error: null
+				};
+			case "pickResource":
+				if (action.resourceId === state.resourceId) return {
+					...state,
+					stylistAnswered: true,
+					step: "when",
+					error: null
+				};
+				return {
+					...state,
+					...clearedSlot,
+					resourceId: action.resourceId,
+					stylistAnswered: true,
+					step: "when",
+					error: null
+				};
+			case "pickSlot":
+				if (state.partyMode === "parallel" && state.items.length > 1) return state;
+				return {
+					...state,
+					startTs: action.startTs,
+					resolvedResourceId: action.resourceId,
+					partyResourceIds: null,
+					step: "details",
+					error: null
+				};
+			case "setPartyMode": {
+				if (action.mode === "parallel" && !config.party.allowParallel) return state;
+				const preference = action.mode === "parallel" ? {
+					resourceId: null,
+					stylistAnswered: true
+				} : {};
+				return {
+					...state,
+					...clearedSlot,
+					...preference,
+					partyMode: action.mode,
+					error: null
+				};
+			}
+			case "pickPartySlot":
+				if (action.mode === "parallel" && !config.party.allowParallel) return state;
+				if (action.resourceIds.length !== state.items.length) return state;
+				return {
+					...state,
+					startTs: action.startTs,
+					partyResourceIds: action.resourceIds,
+					partyMode: action.mode,
+					resolvedResourceId: sharedResourceId(action.resourceIds),
+					step: "details",
+					error: null
+				};
+			case "slotTaken": return {
+				...state,
+				startTs: null,
+				resolvedResourceId: null,
+				partyResourceIds: null,
+				step: "when",
+				error: "slotTaken"
+			};
+			case "submitFailed": return {
+				...state,
+				error: action.error
+			};
+			case "goToStep":
+				if (!canGoToStep(state, action.step)) return state;
+				return {
+					...state,
+					step: action.step,
+					error: null
+				};
+			case "setContact": return {
+				...state,
+				contact: {
+					...state.contact,
+					[action.field]: action.value
+				},
+				error: null
+			};
+			case "setItemField": {
+				if (!state.items[action.index]) return state;
+				const item = withItemField(state.items[action.index], action);
+				return {
+					...state,
+					items: state.items.map((current, index) => index === action.index ? item : current),
+					people: state.people.map((person, index) => index === action.index ? withPersonFields(person, item) : person),
+					error: null
+				};
+			}
+			case "setNotes": return {
+				...state,
+				notes: action.value,
+				error: null
+			};
+			case "setConsent": return {
+				...state,
+				...action.which === "terms" ? { consentTerms: action.accepted } : { consentMarketing: action.accepted },
+				error: null
+			};
+			case "prefill": return applyPrefill(state, action.prefill, action.catalogue);
+		}
+	}
+	/** The children a family link asked for (`?antall=` also applies to a
+	* «Bestill igjen» `?service=` link, intentionally), up to what the salon allows and only
+	* on a kids' service. Through `addService`, so the party limit is the machine's
+	* own and a clamped request raises no error. */
+	function withLinkedParty(state, service, party) {
+		if (!party || !isChildCategory(config, service.category)) return state;
+		const wanted = Math.min(party, Math.max(1, service.maxPerBooking));
+		let next = state;
+		while (next.items.length < wanted) {
+			const after = reduce(next, {
+				type: "addService",
+				service
+			});
+			/* v8 ignore next -- defensive: `wanted` never exceeds the service's own limit */
+			if (after.items.length === next.items.length) break;
+			next = after;
+		}
+		return next;
+	}
+	/**
+	* A «Bestill igjen» link, folded into the state — so a parent re-booking from
+	* `/min-side` opens the wizard with the service, the stylist and the child
+	* already answered and only the time left to pick.
+	*
+	* FILLS BLANKS, NEVER OVERWRITES. Each of the three answers is written only
+	* where the visitor has not given one: the service into an empty basket, the
+	* name onto a line that has none, the stylist while step 2 is still the open
+	* question — nothing answered (`stylistAnswered`, because «Alle» tapped and
+	* «Alle» never touched are the same `null`), no slot chosen, and the visitor
+	* still ON that step. This is not caution for its own sake. The stylist list is fetched
+	* FOR a service, so it does not exist at the moment the link is read; the shell
+	* therefore applies the same prefill twice — once with no stylists, once when
+	* they land — and in between the visitor may have tapped anything. A second
+	* pass that only fills blanks finishes what the first began and cannot undo a
+	* tap. It also makes the function idempotent, which is what lets the shell not
+	* care whether it has already run.
+	*
+	* NOTHING IS TRUSTED BEYOND THE CATALOGUE. The link may be a year old: the
+	* stylist may have left, the service may have been re-created under a new id.
+	* An id the catalogue does not hold is ignored — silently, because there is no
+	* error a parent could act on, and the wizard they are left with is the
+	* ordinary one. A stylist is accepted only if they can do EVERY service in the
+	* basket, which is the rule `StylistStep` filters by; accepting them on the
+	* link's word alone would leave step 2 with nothing selected and step 3
+	* filtered to a diary that cannot take the visit — «Fullt» on every day of the
+	* week at a salon with a free chair, the very failure `pickService` exists to
+	* prevent.
+	*
+	* WHERE IT LANDS is the earliest step with a question still open: nothing
+	* applied → wherever the visitor was; a service → step 2, because «who» has
+	* not been answered even though «Første ledige» would be a valid default; a
+	* stylist too → step 3. Those are the steps the machine's own `pickService` and
+	* `pickResource` move to, and this function reaches them by dispatching those
+	* actions rather than by writing `step` itself — so a prefilled basket obeys
+	* every rule a tapped one does, including the slot-clearing ones.
+	*
+	* Returns the IDENTICAL object when nothing applies, for the same reason
+	* `goToStep` does: React then re-renders nothing, and a test can tell «ignored»
+	* from «rewritten to look the same».
+	*/
+	function applyPrefill(state, prefill, catalogue) {
+		let next = state;
+		if (next.items.length === 0 && prefill.serviceId) {
+			const service = catalogue.services.find((entry) => entry.id === prefill.serviceId);
+			if (service !== void 0) {
+				next = reduce(next, {
+					type: "pickService",
+					service
+				});
+				next = withLinkedParty(next, service, prefill.party);
+			}
+		}
+		if (next.items.length === 0) return state;
+		if (prefill.who) {
+			const who = prefill.who.trim().slice(0, 200);
+			if (who.length > 0 && next.items[0].bookedForName === void 0) next = reduce(next, {
+				type: "setItemField",
+				index: 0,
+				field: "bookedForName",
+				value: who
+			});
+		}
+		if (prefill.resourceId && next.step === "when" && !next.stylistAnswered && next.resourceId === null && next.startTs === null) {
+			const wantedResource = prefill.resourceId;
+			const resource = catalogue.resources.find((entry) => resourceMatches(entry, wantedResource));
+			const basket = next.items.map((item) => item.service.id);
+			if (resource !== void 0 && basket.every((id) => resource.serviceIds.includes(id))) next = reduce(next, {
+				type: "pickResource",
+				resourceId: resource.id
+			});
+		}
+		return next;
+	}
+	/**
+	* What ONE line costs, in øre, at the time the visit was booked for.
+	*
+	* The single definition of «what this child's haircut costs», and the reason
+	* `totalPriceOre` below is a sum of it rather than a second copy of the rule:
+	* the confirmation card prints a price per child and a total underneath them,
+	* and a card whose lines were priced by one rule and whose total was priced by
+	* another read «490 kr + 490 kr = 1 078 kr» to the parent about to pay it.
+	*
+	* The surcharge is per SERVICE — Medal carries `weekend_surcharge_pct` on each
+	* one — so it is applied here, per line, and never as one percentage over a
+	* basket that may hold two different ones.
+	*
+	* `clock.isWeekend` and not `getDay()`: a Saturday 00:30 slot is still Saturday
+	* to the salon while UTC — and a viewer in London — still calls it Friday, and
+	* the surcharge follows the salon's calendar because that is who charges it.
+	*
+	* A null `startTs` means no slot has been chosen yet, which is the base price
+	* rather than a guess at a surcharge.
+	*
+	* `startTs` is the VISIT's start, not the line's own — the two differ only for
+	* a sequential party that crosses midnight into or out of a weekend, which the
+	* salon's opening hours do not permit, and pricing every line off the same
+	* instant is what makes the lines add up to the total the parent agreed to on
+	* step 4.
+	*/
+	function itemPriceOre(service, startTs) {
+		const multiplier = startTs !== null && clock.isWeekend(startTs) ? 1 + service.weekendSurchargePct / 100 : 1;
+		return Math.round(service.priceOre * multiplier);
+	}
+	/**
+	* What the visit costs, in øre, at the time it was booked for.
+	*
+	* Here rather than in either component that shows it, because both of them show
+	* it: step 4's «Bekreft time – 539 kr betales i salongen» and the confirmation
+	* card's «Totalt» have to be the same number, and the surcharge is exactly the
+	* sort of rule that gets applied in one of two places.
+	*/
+	function totalPriceOre(items, startTs) {
+		return items.reduce((sum, { service }) => sum + itemPriceOre(service, startTs), 0);
+	}
+	/**
+	* What is being booked.
+	*
+	* One child gets the service by name, which is what they chose and what they
+	* will look for. A family gets the report's aggregate — «2 tjenester · 60 min
+	* totalt» — because three service names joined by the same separator the bar
+	* uses between its own parts is a sentence nobody can parse at the bottom of a
+	* phone, and because the minutes are the thing a parent planning the afternoon
+	* actually needs.
+	*/
+	function serviceLabel(state) {
+		const { items } = state;
+		if (items.length === 0) return null;
+		if (!showsPartyMode(state)) return items[0].service.name;
+		return `${fill(labels["summary.services"], { count: items.length })}${SEPARATOR}${fill(labels["summary.totalMinutes"], { minutes: visitMinutes(items, state.partyMode) })}`;
+	}
+	/** «Theo, Emma», «2 barn», «Voksen» — who the visit is for, before what. */
+	function peopleLabel(people) {
+		const guests = people.filter((person) => person.key.startsWith("guest:")).length;
+		const parts = people.filter((person) => !person.key.startsWith("guest:")).map((person) => person.name ?? labelText(person.key === "self" ? labels["people.self"] : labels["people.adult"]));
+		if (guests > 0) parts.unshift(fill(labels["people.children"], { count: guests }));
+		return parts.join(", ");
+	}
+	/**
+	* `i dag 15:00`, not `15:00`.
+	*
+	* The bar is read at the bottom of a screen the visitor has been scrolling for
+	* a minute, often after tapping between two days on step 3 — and a bare hour
+	* there is the one part of the summary they can misread without noticing. The
+	* day comes from `salon-clock.ts` along with the hour, so the bar and the chip
+	* the visitor tapped read the same; one of them being on the viewer's clock is
+	* exactly how they stop.
+	*/
+	function timeLabel(startTs, now) {
+		return startTs === null ? null : clock.when(startTs, now);
+	}
+	/**
+	* What the visit costs so far.
+	*
+	* Never a dash: from the moment there is a service there is a price, and it is
+	* `totalPriceOre` — the same function step 4's button and the confirmation card
+	* read — so the three cannot quote different numbers. It can *rise* when the
+	* visitor picks a Saturday, which is the surcharge arriving rather than the bar
+	* changing its mind, and is why the number is recomputed here from `startTs`
+	* instead of being frozen when the service was chosen.
+	*/
+	function priceLabel(state) {
+		/* v8 ignore next -- defensive: `summaryLine` asks only once there is a basket */
+		if (state.items.length === 0) return null;
+		return money.formatMinor(totalPriceOre(state.items, state.startTs));
+	}
+	/**
+	* The single source for the sticky bar, so the bar can never disagree with the
+	* state it is summarising. Chosen parts are joined; parts still to come render
+	* as what is left to do — «Første ledige» for a stylist nobody named, «Velg
+	* tid» for the hour — which is what makes the bar a promise of what is left
+	* rather than a receipt for what is done. A named stylist the catalogue cannot
+	* name is still `—`.
+	*
+	* `now` is a parameter rather than a `Date.now()` inside `clock.when`, because
+	* «i dag» is a claim about when the bar is being *read*: a component that wants
+	* one instant for a whole render — the confirmation card already does this — has
+	* to be able to say so, and a test that asserts «i dag» has to be able to pin it.
+	*/
+	function summaryLine(state, resolveStylistName, now = Date.now()) {
+		/**
+		* A family bar is the report's three parts — «2 tjenester · 60 min totalt ·
+		* 980 kr» — and drops the stylist and the hour rather than dashing them.
+		*
+		* Not brevity: a parallel party has two stylists and no single one to name,
+		* so that part could only ever be a dash, and a dash that can never be filled
+		* in is a promise the bar cannot keep. The when-and-with-whom is on step 3's
+		* chip while the visitor is choosing it and on the confirmation card once
+		* they have, both of which can say «15:00 (Jonas hos Marcus · Emma hos Sara)»
+		* where a one-line sticky bar cannot.
+		*/
+		if (state.items.length === 0 && state.people.length > 0) return peopleLabel(state.people);
+		const party = showsPartyMode(state);
+		const service = serviceLabel(state);
+		if (party) return [service, priceLabel(state)].filter((part) => part !== null).join(SEPARATOR);
+		if (service === null) return "";
+		const unnamedPreference = (state.resolvedResourceId ?? state.resourceId) === null;
+		return [
+			service,
+			stylistLabel(state, resolveStylistName) ?? (unnamedPreference ? labelText(labels["summary.firstAvailable"]) : UNCHOSEN),
+			timeLabel(state.startTs, now) ?? labelText(labels["summary.pickTime"]),
+			priceLabel(state) ?? UNCHOSEN
+		].join(SEPARATOR);
+	}
+	return {
+		maxPeople,
+		initialState,
+		reduce,
+		applyPrefill,
+		canAdvance,
+		canGoToStep,
+		itemPriceOre,
+		totalPriceOre,
+		itemStartTimes,
+		visitMinutes,
+		visitTailMinutes,
+		visitEndTs,
+		showsPartyMode,
+		itemResourceIds,
+		summaryLine,
+		guestChild,
+		isGuestSeat
+	};
+}
+//#endregion
+export { BOOKED_FOR_NAME_MAX_LENGTH, SELF_KEY, canAdvance, canGoToStep, createWizard, guestChild, initialState, isGuestSeat, itemResourceIds, itemStartTimes, showsPartyMode, visitEndTs, visitMinutes, visitTailMinutes };
+
+//# sourceMappingURL=machine.mjs.map