@medalsocial/booking 0.0.0-placeholder.0 → 0.2.0

package/dist/core/attempt-store.d.mts

@@ -0,0 +1,111 @@
+import { WizardItem, WizardState } from "./machine.mjs";
+import { BookingSubmission } from "./types.mjs";
+//#region src/core/attempt-store.d.ts
+/**
+ * One booking attempt, kept where a page reload cannot reach it.
+ *
+ * The wizard's own state is React state, and React state does not survive a
+ * reload — which would be unremarkable if reloading were not the visitor's ONLY
+ * escape from a create request that never answers. Everything here exists for
+ * that one moment: the engine has committed the appointment, the response was
+ * lost, and the browser is now showing a spinner that will never stop.
+ *
+ * Three things have to outlive the page for that to end well:
+ *
+ * 1. The NONCE, which is half the create route's `Idempotency-Key`.
+ * 2. The SUBMISSION it was sent with, which is the other half. A nonce alone is
+ *    not enough and it took a second look to see why: after the reload the
+ *    wizard restarts empty, and if the booking did commit then the slot the
+ *    visitor had is now occupied by their own appointment and gone from
+ *    availability. They cannot reconstruct the body even if they want to, so
+ *    they pick a different time — a different body, a different key, and a
+ *    second haircut for the same child.
+ * 3. The CONFIRMATION, when one was received. The engine mints each manage
+ *    token once and returns the plaintext exactly once; it stores only a hash.
+ *    So a refresh of the confirmation screen before the visitor has saved the
+ *    calendar file used to take every manage link with it, permanently, for a
+ *    booking made without an e-mail address.
+ *
+ * `sessionStorage` and not `localStorage`: an attempt belongs to one tab. A
+ * second tab booking a sibling is a different attempt and must not share a key.
+ *
+ * WHAT THIS PUTS AT REST, said plainly: a stored confirmation contains the
+ * manage links, and a manage link is a bearer credential for that appointment.
+ * It is the same credential that is already in the visitor's address bar, in
+ * their e-mail, and in the calendar file they are about to download — so this
+ * is not a new exposure so much as a shorter-lived copy of an existing one:
+ * same origin, same tab, gone when the tab closes. The alternative is losing
+ * the appointment's only handle to a refresh.
+ */
+/** `<namespace>:booking:attempt`. */
+export declare function attemptStorageKey(namespace: string): string;
+/**
+ * How long a stored attempt is worth restoring.
+ *
+ * The point is to survive a refresh, which happens in seconds. An hour is
+ * generous for that and short enough that a visitor coming back to `/bestill`
+ * later in the same session gets the wizard rather than last time's
+ * confirmation.
+ *
+ * The TTL is no longer the ONLY way out: the confirmation now carries a
+ * «Bestill ny time» control that clears the attempt and mints a fresh one, so a
+ * parent booking a sibling does not have to wait an hour or find another tab.
+ * The age still matters for the visitor who simply closes the screen and comes
+ * back — they never press anything, and an hour-old confirmation is not what
+ * they returned for.
+ */
+export declare const ATTEMPT_TTL_MS: number;
+/**
+ * The visit as it was SUBMITTED, frozen when the POST left.
+ *
+ * «Bekreft»'s child-name inputs stay editable while the request is in flight, so
+ * anything the confirmation reads off the live machine can describe a booking
+ * that was never made: correct «Jonas» to «Emma» during a slow create and
+ * Jonas's appointment is in Medal while the screen — and the calendar file —
+ * both say Emma.
+ */
+export interface SubmittedVisit {
+  items: WizardItem[];
+  startTs: number;
+  partyMode: WizardState['partyMode'];
+  /** One resolved stylist per line, in basket order. */
+  resourceIds: Array<string | null>;
+  /**
+   * Their NAMES, resolved at submit time and stored beside the ids.
+   *
+   * Not derivable after a reload: the names come from the stylist catalogue,
+   * which the shell fetches for the basket's service — and a restored
+   * confirmation has no basket, so that fetch never runs and every id resolves
+   * to null. The refreshed card would lose the stylist from every line the
+   * original card named.
+   */
+  stylistNames: Array<string | null>;
+}
+export interface ConfirmedBooking {
+  id: string;
+  manageHref: string | null;
+}
+export interface BookingAttempt {
+  nonce: string;
+  /** Sent, with no answer yet seen. Replayed on the next load. */
+  pending?: {
+    submission: BookingSubmission;
+    submitted: SubmittedVisit;
+  };
+  /** Answered. Kept so a refresh cannot take the manage links with it. */
+  confirmed?: {
+    bookings: ConfirmedBooking[];
+    submitted: SubmittedVisit;
+  };
+}
+export interface AttemptStore {
+  readonly ATTEMPT_STORAGE_KEY: string;
+  readAttempt(): BookingAttempt;
+  rememberPending(attempt: BookingAttempt, pending: NonNullable<BookingAttempt['pending']>): void;
+  rememberConfirmed(attempt: BookingAttempt, confirmed: NonNullable<BookingAttempt['confirmed']>): void;
+  clearAttempt(): void;
+}
+/** The attempt store under `<namespace>:booking:attempt`. */
+export declare function createAttemptStore(namespace: string): AttemptStore;
+//#endregion
+//# sourceMappingURL=attempt-store.d.mts.map

package/dist/core/attempt-store.mjs

@@ -0,0 +1,159 @@
+//#region src/core/attempt-store.ts
+/**
+* One booking attempt, kept where a page reload cannot reach it.
+*
+* The wizard's own state is React state, and React state does not survive a
+* reload — which would be unremarkable if reloading were not the visitor's ONLY
+* escape from a create request that never answers. Everything here exists for
+* that one moment: the engine has committed the appointment, the response was
+* lost, and the browser is now showing a spinner that will never stop.
+*
+* Three things have to outlive the page for that to end well:
+*
+* 1. The NONCE, which is half the create route's `Idempotency-Key`.
+* 2. The SUBMISSION it was sent with, which is the other half. A nonce alone is
+*    not enough and it took a second look to see why: after the reload the
+*    wizard restarts empty, and if the booking did commit then the slot the
+*    visitor had is now occupied by their own appointment and gone from
+*    availability. They cannot reconstruct the body even if they want to, so
+*    they pick a different time — a different body, a different key, and a
+*    second haircut for the same child.
+* 3. The CONFIRMATION, when one was received. The engine mints each manage
+*    token once and returns the plaintext exactly once; it stores only a hash.
+*    So a refresh of the confirmation screen before the visitor has saved the
+*    calendar file used to take every manage link with it, permanently, for a
+*    booking made without an e-mail address.
+*
+* `sessionStorage` and not `localStorage`: an attempt belongs to one tab. A
+* second tab booking a sibling is a different attempt and must not share a key.
+*
+* WHAT THIS PUTS AT REST, said plainly: a stored confirmation contains the
+* manage links, and a manage link is a bearer credential for that appointment.
+* It is the same credential that is already in the visitor's address bar, in
+* their e-mail, and in the calendar file they are about to download — so this
+* is not a new exposure so much as a shorter-lived copy of an existing one:
+* same origin, same tab, gone when the tab closes. The alternative is losing
+* the appointment's only handle to a refresh.
+*/
+/** `<namespace>:booking:attempt`. */
+function attemptStorageKey(namespace) {
+	return `${namespace}:booking:attempt`;
+}
+/**
+* How long a stored attempt is worth restoring.
+*
+* The point is to survive a refresh, which happens in seconds. An hour is
+* generous for that and short enough that a visitor coming back to `/bestill`
+* later in the same session gets the wizard rather than last time's
+* confirmation.
+*
+* The TTL is no longer the ONLY way out: the confirmation now carries a
+* «Bestill ny time» control that clears the attempt and mints a fresh one, so a
+* parent booking a sibling does not have to wait an hour or find another tab.
+* The age still matters for the visitor who simply closes the screen and comes
+* back — they never press anything, and an hour-old confirmation is not what
+* they returned for.
+*/
+const ATTEMPT_TTL_MS = 36e5;
+/** The attempt store under `<namespace>:booking:attempt`. */
+function createAttemptStore(namespace) {
+	const STORAGE_KEY = attemptStorageKey(namespace);
+	/**
+	* Every path through this module falls back to «no stored attempt» rather than
+	* throwing.
+	*
+	* There is no `sessionStorage` during the server render, Safari's private mode
+	* has historically thrown on write, and a visitor may simply have storage
+	* turned off. Losing the idempotency guarantee is bad; refusing to let somebody
+	* book a haircut because their browser will not hold a string is worse.
+	*/
+	function readStored() {
+		if (typeof window === "undefined") return null;
+		try {
+			const raw = window.sessionStorage.getItem(STORAGE_KEY);
+			if (!raw) return null;
+			const parsed = JSON.parse(raw);
+			if (typeof parsed?.nonce !== "string" || typeof parsed?.at !== "number") return null;
+			if (Date.now() - parsed.at > 36e5) return null;
+			return parsed;
+		} catch {
+			return null;
+		}
+	}
+	function write(attempt) {
+		if (typeof window === "undefined") return;
+		try {
+			const stored = {
+				...attempt,
+				at: Date.now()
+			};
+			window.sessionStorage.setItem(STORAGE_KEY, JSON.stringify(stored));
+		} catch {}
+	}
+	/**
+	* The attempt this tab is on — the one already stored, or a fresh one.
+	*
+	* Reading MINTS and stores when there is nothing to read, so the nonce exists
+	* from the moment the wizard mounts rather than from the moment somebody
+	* presses «Bekreft time». A nonce created at submit would be created again by
+	* the reload it is supposed to survive.
+	*/
+	function readAttempt() {
+		const stored = readStored();
+		if (stored !== null) {
+			const { at: _at, ...attempt } = stored;
+			return attempt;
+		}
+		const fresh = { nonce: crypto.randomUUID() };
+		write(fresh);
+		return fresh;
+	}
+	/** Record what was just sent, BEFORE it is sent. A body stored after the
+	* response is a body that is not there when the response never comes. */
+	function rememberPending(attempt, pending) {
+		write({
+			nonce: attempt.nonce,
+			pending
+		});
+	}
+	/**
+	* Record the answer, and drop the pending submission with it.
+	*
+	* Order matters on the next load: a stored confirmation is shown, a stored
+	* pending submission is replayed. Leaving both would replay a booking that has
+	* already been confirmed — harmless, because the key makes it a replay, but a
+	* needless round trip on every reload of the confirmation.
+	*/
+	function rememberConfirmed(attempt, confirmed) {
+		write({
+			nonce: attempt.nonce,
+			confirmed
+		});
+	}
+	/**
+	* Forget the attempt entirely.
+	*
+	* For the failures that are certainly NOT «we do not know»: a slot that was
+	* taken, or a body the engine refused. Both mean no appointment was made and
+	* the visitor is about to build a different one, so replaying this on the next
+	* load would resend a submission that has already been answered — with a
+	* «Bekreft time» nobody pressed.
+	*/
+	function clearAttempt() {
+		if (typeof window === "undefined") return;
+		try {
+			window.sessionStorage.removeItem(STORAGE_KEY);
+		} catch {}
+	}
+	return {
+		ATTEMPT_STORAGE_KEY: STORAGE_KEY,
+		readAttempt,
+		rememberPending,
+		rememberConfirmed,
+		clearAttempt
+	};
+}
+//#endregion
+export { ATTEMPT_TTL_MS, attemptStorageKey, createAttemptStore };
+
+//# sourceMappingURL=attempt-store.mjs.map

package/dist/core/attempt-store.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempt-store.mjs","names":[],"sources":["../../src/core/attempt-store.ts"],"sourcesContent":["import type { WizardItem, WizardState } from './machine';\nimport type { BookingSubmission } from './types';\n\n/**\n * One booking attempt, kept where a page reload cannot reach it.\n *\n * The wizard's own state is React state, and React state does not survive a\n * reload — which would be unremarkable if reloading were not the visitor's ONLY\n * escape from a create request that never answers. Everything here exists for\n * that one moment: the engine has committed the appointment, the response was\n * lost, and the browser is now showing a spinner that will never stop.\n *\n * Three things have to outlive the page for that to end well:\n *\n * 1. The NONCE, which is half the create route's `Idempotency-Key`.\n * 2. The SUBMISSION it was sent with, which is the other half. A nonce alone is\n *    not enough and it took a second look to see why: after the reload the\n *    wizard restarts empty, and if the booking did commit then the slot the\n *    visitor had is now occupied by their own appointment and gone from\n *    availability. They cannot reconstruct the body even if they want to, so\n *    they pick a different time — a different body, a different key, and a\n *    second haircut for the same child.\n * 3. The CONFIRMATION, when one was received. The engine mints each manage\n *    token once and returns the plaintext exactly once; it stores only a hash.\n *    So a refresh of the confirmation screen before the visitor has saved the\n *    calendar file used to take every manage link with it, permanently, for a\n *    booking made without an e-mail address.\n *\n * `sessionStorage` and not `localStorage`: an attempt belongs to one tab. A\n * second tab booking a sibling is a different attempt and must not share a key.\n *\n * WHAT THIS PUTS AT REST, said plainly: a stored confirmation contains the\n * manage links, and a manage link is a bearer credential for that appointment.\n * It is the same credential that is already in the visitor's address bar, in\n * their e-mail, and in the calendar file they are about to download — so this\n * is not a new exposure so much as a shorter-lived copy of an existing one:\n * same origin, same tab, gone when the tab closes. The alternative is losing\n * the appointment's only handle to a refresh.\n */\n\n/** `<namespace>:booking:attempt`. */\nexport function attemptStorageKey(namespace: string): string {\n  return `${namespace}:booking:attempt`;\n}\n\n/**\n * How long a stored attempt is worth restoring.\n *\n * The point is to survive a refresh, which happens in seconds. An hour is\n * generous for that and short enough that a visitor coming back to `/bestill`\n * later in the same session gets the wizard rather than last time's\n * confirmation.\n *\n * The TTL is no longer the ONLY way out: the confirmation now carries a\n * «Bestill ny time» control that clears the attempt and mints a fresh one, so a\n * parent booking a sibling does not have to wait an hour or find another tab.\n * The age still matters for the visitor who simply closes the screen and comes\n * back — they never press anything, and an hour-old confirmation is not what\n * they returned for.\n */\nexport const ATTEMPT_TTL_MS = 60 * 60 * 1000;\n\n/**\n * The visit as it was SUBMITTED, frozen when the POST left.\n *\n * «Bekreft»'s child-name inputs stay editable while the request is in flight, so\n * anything the confirmation reads off the live machine can describe a booking\n * that was never made: correct «Jonas» to «Emma» during a slow create and\n * Jonas's appointment is in Medal while the screen — and the calendar file —\n * both say Emma.\n */\nexport interface SubmittedVisit {\n  items: WizardItem[];\n  startTs: number;\n  partyMode: WizardState['partyMode'];\n  /** One resolved stylist per line, in basket order. */\n  resourceIds: Array<string | null>;\n  /**\n   * Their NAMES, resolved at submit time and stored beside the ids.\n   *\n   * Not derivable after a reload: the names come from the stylist catalogue,\n   * which the shell fetches for the basket's service — and a restored\n   * confirmation has no basket, so that fetch never runs and every id resolves\n   * to null. The refreshed card would lose the stylist from every line the\n   * original card named.\n   */\n  stylistNames: Array<string | null>;\n}\n\nexport interface ConfirmedBooking {\n  id: string;\n  manageHref: string | null;\n}\n\nexport interface BookingAttempt {\n  nonce: string;\n  /** Sent, with no answer yet seen. Replayed on the next load. */\n  pending?: { submission: BookingSubmission; submitted: SubmittedVisit };\n  /** Answered. Kept so a refresh cannot take the manage links with it. */\n  confirmed?: { bookings: ConfirmedBooking[]; submitted: SubmittedVisit };\n}\n\ninterface StoredAttempt extends BookingAttempt {\n  /** When this record was last written, for `ATTEMPT_TTL_MS`. */\n  at: number;\n}\n\nexport interface AttemptStore {\n  readonly ATTEMPT_STORAGE_KEY: string;\n  readAttempt(): BookingAttempt;\n  rememberPending(attempt: BookingAttempt, pending: NonNullable<BookingAttempt['pending']>): void;\n  rememberConfirmed(\n    attempt: BookingAttempt,\n    confirmed: NonNullable<BookingAttempt['confirmed']>\n  ): void;\n  clearAttempt(): void;\n}\n\n/** The attempt store under `<namespace>:booking:attempt`. */\nexport function createAttemptStore(namespace: string): AttemptStore {\n  const STORAGE_KEY = attemptStorageKey(namespace);\n\n  /**\n   * Every path through this module falls back to «no stored attempt» rather than\n   * throwing.\n   *\n   * There is no `sessionStorage` during the server render, Safari's private mode\n   * has historically thrown on write, and a visitor may simply have storage\n   * turned off. Losing the idempotency guarantee is bad; refusing to let somebody\n   * book a haircut because their browser will not hold a string is worse.\n   */\n  function readStored(): StoredAttempt | null {\n    if (typeof window === 'undefined') return null;\n    try {\n      const raw = window.sessionStorage.getItem(STORAGE_KEY);\n      if (!raw) return null;\n      const parsed = JSON.parse(raw) as StoredAttempt;\n      if (typeof parsed?.nonce !== 'string' || typeof parsed?.at !== 'number') return null;\n      if (Date.now() - parsed.at > ATTEMPT_TTL_MS) return null;\n      return parsed;\n    } catch {\n      return null;\n    }\n  }\n\n  function write(attempt: BookingAttempt): void {\n    if (typeof window === 'undefined') return;\n    try {\n      const stored: StoredAttempt = { ...attempt, at: Date.now() };\n      window.sessionStorage.setItem(STORAGE_KEY, JSON.stringify(stored));\n    } catch {\n      // The attempt goes on without the guarantee. See the note above.\n    }\n  }\n\n  /**\n   * The attempt this tab is on — the one already stored, or a fresh one.\n   *\n   * Reading MINTS and stores when there is nothing to read, so the nonce exists\n   * from the moment the wizard mounts rather than from the moment somebody\n   * presses «Bekreft time». A nonce created at submit would be created again by\n   * the reload it is supposed to survive.\n   */\n  function readAttempt(): BookingAttempt {\n    const stored = readStored();\n    if (stored !== null) {\n      const { at: _at, ...attempt } = stored;\n      return attempt;\n    }\n    const fresh: BookingAttempt = { nonce: crypto.randomUUID() };\n    write(fresh);\n    return fresh;\n  }\n\n  /** Record what was just sent, BEFORE it is sent. A body stored after the\n   * response is a body that is not there when the response never comes. */\n  function rememberPending(\n    attempt: BookingAttempt,\n    pending: NonNullable<BookingAttempt['pending']>\n  ): void {\n    write({ nonce: attempt.nonce, pending });\n  }\n\n  /**\n   * Record the answer, and drop the pending submission with it.\n   *\n   * Order matters on the next load: a stored confirmation is shown, a stored\n   * pending submission is replayed. Leaving both would replay a booking that has\n   * already been confirmed — harmless, because the key makes it a replay, but a\n   * needless round trip on every reload of the confirmation.\n   */\n  function rememberConfirmed(\n    attempt: BookingAttempt,\n    confirmed: NonNullable<BookingAttempt['confirmed']>\n  ): void {\n    write({ nonce: attempt.nonce, confirmed });\n  }\n\n  /**\n   * Forget the attempt entirely.\n   *\n   * For the failures that are certainly NOT «we do not know»: a slot that was\n   * taken, or a body the engine refused. Both mean no appointment was made and\n   * the visitor is about to build a different one, so replaying this on the next\n   * load would resend a submission that has already been answered — with a\n   * «Bekreft time» nobody pressed.\n   */\n  function clearAttempt(): void {\n    if (typeof window === 'undefined') return;\n    try {\n      window.sessionStorage.removeItem(STORAGE_KEY);\n    } catch {\n      // Nothing to do, and nothing worth failing a booking over.\n    }\n  }\n\n  return {\n    ATTEMPT_STORAGE_KEY: STORAGE_KEY,\n    readAttempt,\n    rememberPending,\n    rememberConfirmed,\n    clearAttempt,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,kBAAkB,WAA2B;CAC3D,OAAO,GAAG,UAAU;AACtB;;;;;;;;;;;;;;;;AAiBA,MAAa,iBAAiB;;AA2D9B,SAAgB,mBAAmB,WAAiC;CAClE,MAAM,cAAc,kBAAkB,SAAS;;;;;;;;;;CAW/C,SAAS,aAAmC;EAC1C,IAAI,OAAO,WAAW,aAAa,OAAO;EAC1C,IAAI;GACF,MAAM,MAAM,OAAO,eAAe,QAAQ,WAAW;GACrD,IAAI,CAAC,KAAK,OAAO;GACjB,MAAM,SAAS,KAAK,MAAM,GAAG;GAC7B,IAAI,OAAO,QAAQ,UAAU,YAAY,OAAO,QAAQ,OAAO,UAAU,OAAO;GAChF,IAAI,KAAK,IAAI,IAAI,OAAO,KAAA,MAAqB,OAAO;GACpD,OAAO;EACT,QAAQ;GACN,OAAO;EACT;CACF;CAEA,SAAS,MAAM,SAA+B;EAC5C,IAAI,OAAO,WAAW,aAAa;EACnC,IAAI;GACF,MAAM,SAAwB;IAAE,GAAG;IAAS,IAAI,KAAK,IAAI;GAAE;GAC3D,OAAO,eAAe,QAAQ,aAAa,KAAK,UAAU,MAAM,CAAC;EACnE,QAAQ,CAER;CACF;;;;;;;;;CAUA,SAAS,cAA8B;EACrC,MAAM,SAAS,WAAW;EAC1B,IAAI,WAAW,MAAM;GACnB,MAAM,EAAE,IAAI,KAAK,GAAG,YAAY;GAChC,OAAO;EACT;EACA,MAAM,QAAwB,EAAE,OAAO,OAAO,WAAW,EAAE;EAC3D,MAAM,KAAK;EACX,OAAO;CACT;;;CAIA,SAAS,gBACP,SACA,SACM;EACN,MAAM;GAAE,OAAO,QAAQ;GAAO;EAAQ,CAAC;CACzC;;;;;;;;;CAUA,SAAS,kBACP,SACA,WACM;EACN,MAAM;GAAE,OAAO,QAAQ;GAAO;EAAU,CAAC;CAC3C;;;;;;;;;;CAWA,SAAS,eAAqB;EAC5B,IAAI,OAAO,WAAW,aAAa;EACnC,IAAI;GACF,OAAO,eAAe,WAAW,WAAW;EAC9C,QAAQ,CAER;CACF;CAEA,OAAO;EACL,qBAAqB;EACrB;EACA;EACA;EACA;CACF;AACF"}

package/dist/core/categories.d.mts

@@ -0,0 +1,27 @@
+import { BookingConfig } from "./config.mjs";
+//#region src/core/categories.d.ts
+type CategoryConfig = Pick<BookingConfig, 'categories' | 'fallbackCategory'>;
+/** The configured keys, in display order. */
+export declare function categoryOrder(config: CategoryConfig): string[];
+/** A raw Medal category as one of the configured keys, or the fallback. */
+export declare function normaliseCategory(config: CategoryConfig, raw: string | null | undefined): string;
+/** Whether a (raw) category is a kids' group. */
+export declare function isChildCategory(config: CategoryConfig, raw: string | null | undefined): boolean;
+/** The first kids' group, the one a link's «for a child» means. `null` when none is configured. */
+export declare function childCategory(config: CategoryConfig): string | null;
+/**
+ * The adult group a service «grows up» into, by its group's `adultEquivalent`:
+ * the group's own key, or the first `nameIncludes` rule the name matches.
+ * `null` when the group names none.
+ */
+export declare function adultCategoryFor(config: CategoryConfig, service: {
+  name: string;
+  category: string;
+}): string | null;
+/** The services in the adult group `service` grows up into — empty when it names none. */
+export declare function adultEquivalent<S extends {
+  name: string;
+  category: string;
+}>(config: CategoryConfig, service: S, services: readonly S[]): S[];
+//#endregion
+//# sourceMappingURL=categories.d.mts.map

package/dist/core/categories.mjs

@@ -0,0 +1,42 @@
+//#region src/core/categories.ts
+/** The configured keys, in display order. */
+function categoryOrder(config) {
+	return config.categories.map((category) => category.key);
+}
+/** A raw Medal category as one of the configured keys, or the fallback. */
+function normaliseCategory(config, raw) {
+	return config.categories.some((category) => category.key === raw) ? raw : config.fallbackCategory;
+}
+function categoryFor(config, raw) {
+	const key = normaliseCategory(config, raw);
+	return config.categories.find((category) => category.key === key);
+}
+/** Whether a (raw) category is a kids' group. */
+function isChildCategory(config, raw) {
+	return categoryFor(config, raw).audience === "child";
+}
+/** The first kids' group, the one a link's «for a child» means. `null` when none is configured. */
+function childCategory(config) {
+	return config.categories.find((category) => category.audience === "child")?.key ?? null;
+}
+/**
+* The adult group a service «grows up» into, by its group's `adultEquivalent`:
+* the group's own key, or the first `nameIncludes` rule the name matches.
+* `null` when the group names none.
+*/
+function adultCategoryFor(config, service) {
+	const rule = categoryFor(config, service.category).adultEquivalent;
+	if (rule === void 0) return null;
+	if (typeof rule === "string") return rule;
+	const name = service.name.toLocaleLowerCase();
+	return rule.find((entry) => name.includes(entry.nameIncludes.toLocaleLowerCase()))?.category ?? null;
+}
+/** The services in the adult group `service` grows up into — empty when it names none. */
+function adultEquivalent(config, service, services) {
+	const target = adultCategoryFor(config, service);
+	return target === null ? [] : services.filter((candidate) => candidate.category === target);
+}
+//#endregion
+export { adultCategoryFor, adultEquivalent, categoryOrder, childCategory, isChildCategory, normaliseCategory };
+
+//# sourceMappingURL=categories.mjs.map

package/dist/core/categories.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"categories.mjs","names":[],"sources":["../../src/core/categories.ts"],"sourcesContent":["/**\n * Medal's service `category` is a free string, and a business can add one in\n * the dashboard at any time. The site groups by its own configured list\n * (`config.categories`), in display order, and anything unrecognised joins the\n * catch-all (`config.fallbackCategory`) rather than dropping off the page —\n * bookable, priced, and invisible.\n *\n * `audience: 'child'` is the kids' path: what the wizard used to spell as the\n * literal `'barn'` (a guest child's seat, the held link service, `?antall=`).\n */\n\nimport type { BookingCategory, BookingConfig } from './config';\n\ntype CategoryConfig = Pick<BookingConfig, 'categories' | 'fallbackCategory'>;\n\n/** The configured keys, in display order. */\nexport function categoryOrder(config: CategoryConfig): string[] {\n  return config.categories.map((category) => category.key);\n}\n\n/** A raw Medal category as one of the configured keys, or the fallback. */\nexport function normaliseCategory(config: CategoryConfig, raw: string | null | undefined): string {\n  return config.categories.some((category) => category.key === raw)\n    ? (raw as string)\n    : config.fallbackCategory;\n}\n\nfunction categoryFor(config: CategoryConfig, raw: string | null | undefined): BookingCategory {\n  const key = normaliseCategory(config, raw);\n  return config.categories.find((category) => category.key === key) as BookingCategory;\n}\n\n/** Whether a (raw) category is a kids' group. */\nexport function isChildCategory(config: CategoryConfig, raw: string | null | undefined): boolean {\n  return categoryFor(config, raw).audience === 'child';\n}\n\n/** The first kids' group, the one a link's «for a child» means. `null` when none is configured. */\nexport function childCategory(config: CategoryConfig): string | null {\n  return config.categories.find((category) => category.audience === 'child')?.key ?? null;\n}\n\n/**\n * The adult group a service «grows up» into, by its group's `adultEquivalent`:\n * the group's own key, or the first `nameIncludes` rule the name matches.\n * `null` when the group names none.\n */\nexport function adultCategoryFor(\n  config: CategoryConfig,\n  service: { name: string; category: string }\n): string | null {\n  const rule = categoryFor(config, service.category).adultEquivalent;\n  if (rule === undefined) return null;\n  if (typeof rule === 'string') return rule;\n  const name = service.name.toLocaleLowerCase();\n  return (\n    rule.find((entry) => name.includes(entry.nameIncludes.toLocaleLowerCase()))?.category ?? null\n  );\n}\n\n/** The services in the adult group `service` grows up into — empty when it names none. */\nexport function adultEquivalent<S extends { name: string; category: string }>(\n  config: CategoryConfig,\n  service: S,\n  services: readonly S[]\n): S[] {\n  const target = adultCategoryFor(config, service);\n  return target === null ? [] : services.filter((candidate) => candidate.category === target);\n}\n"],"mappings":";;AAgBA,SAAgB,cAAc,QAAkC;CAC9D,OAAO,OAAO,WAAW,KAAK,aAAa,SAAS,GAAG;AACzD;;AAGA,SAAgB,kBAAkB,QAAwB,KAAwC;CAChG,OAAO,OAAO,WAAW,MAAM,aAAa,SAAS,QAAQ,GAAG,IAC3D,MACD,OAAO;AACb;AAEA,SAAS,YAAY,QAAwB,KAAiD;CAC5F,MAAM,MAAM,kBAAkB,QAAQ,GAAG;CACzC,OAAO,OAAO,WAAW,MAAM,aAAa,SAAS,QAAQ,GAAG;AAClE;;AAGA,SAAgB,gBAAgB,QAAwB,KAAyC;CAC/F,OAAO,YAAY,QAAQ,GAAG,CAAC,CAAC,aAAa;AAC/C;;AAGA,SAAgB,cAAc,QAAuC;CACnE,OAAO,OAAO,WAAW,MAAM,aAAa,SAAS,aAAa,OAAO,CAAC,EAAE,OAAO;AACrF;;;;;;AAOA,SAAgB,iBACd,QACA,SACe;CACf,MAAM,OAAO,YAAY,QAAQ,QAAQ,QAAQ,CAAC,CAAC;CACnD,IAAI,SAAS,KAAA,GAAW,OAAO;CAC/B,IAAI,OAAO,SAAS,UAAU,OAAO;CACrC,MAAM,OAAO,QAAQ,KAAK,kBAAkB;CAC5C,OACE,KAAK,MAAM,UAAU,KAAK,SAAS,MAAM,aAAa,kBAAkB,CAAC,CAAC,CAAC,EAAE,YAAY;AAE7F;;AAGA,SAAgB,gBACd,QACA,SACA,UACK;CACL,MAAM,SAAS,iBAAiB,QAAQ,OAAO;CAC/C,OAAO,WAAW,OAAO,CAAC,IAAI,SAAS,QAAQ,cAAc,UAAU,aAAa,MAAM;AAC5F"}

package/dist/core/clock.d.mts

@@ -0,0 +1,33 @@
+import { BookingLabels } from "./labels.mjs";
+import { BookingConfig } from "./config.mjs";
+//#region src/core/clock.d.ts
+export interface Clock {
+  readonly timeZone: string;
+  /** The day part keys, in order. */
+  readonly dayparts: readonly string[];
+  dayStart(ts: number, offsetDays?: number): number;
+  window(fromTs: number, rangeDays: number): {
+    fromTs: number;
+    toTs: number;
+    days: number[];
+  };
+  formatTime(ts: number): string;
+  hour(ts: number): number;
+  dayKey(ts: number): string;
+  isWeekend(ts: number): boolean;
+  daysBetween(from: number, to: number): number;
+  daypartOf(ts: number): string;
+  daypartLabel(key: string): string;
+  dayLabel(ts: number, now?: number): string;
+  dayChip(ts: number, now?: number): string;
+  when(ts: number, now?: number): string;
+  date(ts: number): string;
+  dateTime(ts: number): string;
+  weekday(ts: number): string;
+}
+export type ClockConfig = Pick<BookingConfig, 'timeZone' | 'locale' | 'dayparts'> & {
+  labels?: Partial<BookingLabels>;
+};
+export declare function createClock(config: ClockConfig): Clock;
+//#endregion
+//# sourceMappingURL=clock.d.mts.map

package/dist/core/clock.mjs

@@ -0,0 +1,251 @@
+import { fill, labelText, resolveLabels } from "./labels.mjs";
+//#region src/core/clock.ts
+/**
+* Built once each: constructing a formatter is the expensive half of `Intl`,
+* and the time step formats every slot in a week on each re-render.
+*/
+const FORMATTERS = /* @__PURE__ */ new Map();
+function formattersFor(timeZone, locale) {
+	const cacheKey = `${timeZone}\u0000${locale}`;
+	const cached = FORMATTERS.get(cacheKey);
+	if (cached !== void 0) return cached;
+	const built = {
+		time: new Intl.DateTimeFormat(locale, {
+			timeZone,
+			hour: "2-digit",
+			minute: "2-digit",
+			hourCycle: "h23"
+		}),
+		parts: new Intl.DateTimeFormat("en-US", {
+			timeZone,
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			hourCycle: "h23",
+			weekday: "short"
+		}),
+		weekdayLong: new Intl.DateTimeFormat(locale, {
+			timeZone,
+			weekday: "long"
+		}),
+		weekdayShort: new Intl.DateTimeFormat(locale, {
+			timeZone,
+			weekday: "short",
+			day: "numeric"
+		}),
+		dayMonth: new Intl.DateTimeFormat(locale, {
+			timeZone,
+			day: "numeric",
+			month: "short"
+		}),
+		fullDate: new Intl.DateTimeFormat(locale, {
+			timeZone,
+			weekday: "short",
+			day: "numeric",
+			month: "short"
+		}),
+		wallClock: new Intl.DateTimeFormat("en-US", {
+			timeZone,
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit",
+			hourCycle: "h23"
+		})
+	};
+	FORMATTERS.set(cacheKey, built);
+	return built;
+}
+/** One clock per config object: every factory that needs the clock asks for it. */
+const CLOCKS = /* @__PURE__ */ new WeakMap();
+function createClock(config) {
+	const known = CLOCKS.get(config);
+	if (known !== void 0) return known;
+	const clock = buildClock(config);
+	CLOCKS.set(config, clock);
+	return clock;
+}
+function buildClock(config) {
+	const { timeZone } = config;
+	const f = formattersFor(timeZone, config.locale);
+	const labels = resolveLabels(config.locale, config.labels);
+	const dayparts = config.dayparts;
+	function partsOf(ts) {
+		const out = {};
+		for (const part of f.parts.formatToParts(ts)) out[part.type] = part.value;
+		return out;
+	}
+	/**
+	* How far ahead of UTC the business is at a given instant — `+1 h` in winter,
+	* `+2 h` in summer for Oslo.
+	*
+	* Read from the zone database rather than assumed, because the whole point of
+	* the two functions below is the two days a year when it changes.
+	*/
+	function offsetMs(ts) {
+		const out = {};
+		for (const part of f.wallClock.formatToParts(ts)) out[part.type] = part.value;
+		return Date.UTC(Number(out.year), Number(out.month) - 1, Number(out.day), Number(out.hour), Number(out.minute), Number(out.second)) - (ts - (ts % 1e3 + 1e3) % 1e3);
+	}
+	/**
+	* Midnight on the business's clock, `offsetDays` calendar days after the day
+	* `ts` falls in.
+	*
+	* The reason this is not `ts + n * 86_400_000`: adding a fixed 24 hours assumes
+	* every day is 24 hours long, and two of them a year are not. Late on the
+	* Saturday before the clocks go forward, +24 h lands on the Monday and Sunday
+	* disappears; early on the Sunday they go back, +24 h lands on the same Sunday
+	* again and the far end of the week is lost. Either way a day strip built that
+	* way stops describing the week the availability query asked about.
+	*
+	* Two passes, because the offset has to be read at the answer rather than at the
+	* guess: `wall` is midnight on the target date treated as if the zone were UTC,
+	* and the offset in force at the true instant is the one that turns it back into
+	* one. The second read settles the case where the guess falls on the other side
+	* of a transition from the day it belongs to.
+	*/
+	function dayStart(ts, offsetDays = 0) {
+		const parts = partsOf(ts);
+		const wall = Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day) + offsetDays);
+		return wall - offsetMs(wall - offsetMs(wall));
+	}
+	/**
+	* The days the time step may offer and the instant the availability query
+	* stops at — derived together, so they cannot disagree.
+	*
+	* `days` is one instant inside each business day, starting with the day
+	* `fromTs` falls in; `toTs` is the midnight that ends the last of them. That is
+	* the whole contract: every opening the engine can return has a chip to sit
+	* on, and every chip covers a stretch the engine was actually asked about.
+	*
+	* `fromTs` is returned untouched and is NOT snapped to midnight: it is the
+	* moment the visitor is standing in, and a query that started at this morning's
+	* midnight would ask the engine about hours that are already gone.
+	*/
+	function window(fromTs, rangeDays) {
+		return {
+			fromTs,
+			toTs: dayStart(fromTs, rangeDays),
+			days: Array.from({ length: rangeDays }, (_, index) => dayStart(fromTs, index))
+		};
+	}
+	/** `15:00` — the string on the chip, the summary bar and the confirmation. */
+	function formatTime(ts) {
+		return f.time.format(ts);
+	}
+	/** The hour 0–23 as the business reads it. */
+	function hour(ts) {
+		return Number(partsOf(ts).hour);
+	}
+	/**
+	* `2026-09-03` — the identity of a *business* day, which is what slots group
+	* by. Slicing an ISO string instead would file 00:30 on Thursday under
+	* Wednesday and split one opening day across two headings.
+	*/
+	function dayKey(ts) {
+		const parts = partsOf(ts);
+		return `${parts.year}-${parts.month}-${parts.day}`;
+	}
+	function isWeekend(ts) {
+		const weekday = partsOf(ts).weekday;
+		return weekday === "Sat" || weekday === "Sun";
+	}
+	function utcMidnight(ts) {
+		const parts = partsOf(ts);
+		return Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day));
+	}
+	/**
+	* Whole days between two instants on the business calendar, so «tomorrow»
+	* means the next opening day rather than "in 24 hours". Anchoring both to UTC
+	* midnight after the parts have already been read in the zone keeps the
+	* arithmetic clear of the hour the clocks change, where a naive subtraction
+	* is off by one.
+	*/
+	function daysBetween(from, to) {
+		return (utcMidnight(to) - utcMidnight(from)) / 864e5;
+	}
+	/** The configured part the hour falls in — on the business's clock. */
+	function daypartOf(ts) {
+		const h = hour(ts);
+		return (dayparts.find((candidate) => h >= candidate.from && h < candidate.to) ?? dayparts[dayparts.length - 1]).key;
+	}
+	function daypartLabel(key) {
+		const label = labels[`daypart.${key}`];
+		return label === void 0 ? key : labelText(label);
+	}
+	/**
+	* `i dag` / `i morgen` / `lørdag` / `10. sep.`, mid-sentence.
+	*
+	* The weekday name stops being useful after six days — «torsdag» could then be
+	* either of two Thursdays — so the date takes over rather than being ambiguous
+	* about which week the business expects you.
+	*/
+	function dayLabel(ts, now = Date.now()) {
+		const days = daysBetween(now, ts);
+		if (days === 0) return labelText(labels["clock.today"]);
+		if (days === 1) return labelText(labels["clock.tomorrow"]);
+		if (days > 1 && days < 7) return f.weekdayLong.format(ts);
+		return f.dayMonth.format(ts);
+	}
+	/** The same day, sized for a chip in the date strip: `I dag`, `lør. 5.`. */
+	function dayChip(ts, now = Date.now()) {
+		const days = daysBetween(now, ts);
+		if (days === 0) return labelText(labels["clock.todayChip"]);
+		if (days === 1) return labelText(labels["clock.tomorrowChip"]);
+		return f.weekdayShort.format(ts);
+	}
+	/** `i dag 14:15` — a day and a time in one breath, for «Neste ledige». */
+	function when(ts, now = Date.now()) {
+		return fill(labels["clock.when"], {
+			day: dayLabel(ts, now),
+			time: formatTime(ts)
+		});
+	}
+	/**
+	* `tor. 8. okt.` — the calendar date, with no reference to now.
+	*
+	* The month keeps ICU's trailing full stop (`okt.`, not `okt`), because that is
+	* how Norwegian abbreviates a month and this file does not second-guess the
+	* locale data.
+	*/
+	function date(ts) {
+		return f.fullDate.format(ts);
+	}
+	/** `tor. 8. okt. kl. 15:00` — the whole appointment in one line, absolute in both halves. */
+	function dateTime(ts) {
+		return fill(labels["clock.dateTime"], {
+			date: date(ts),
+			time: formatTime(ts)
+		});
+	}
+	/** `lørdag` — the weekday's own name, for «lørdagspris». */
+	function weekday(ts) {
+		return f.weekdayLong.format(ts);
+	}
+	return {
+		timeZone,
+		dayparts: dayparts.map((part) => part.key),
+		dayStart,
+		window,
+		formatTime,
+		hour,
+		dayKey,
+		isWeekend,
+		daysBetween,
+		daypartOf,
+		daypartLabel,
+		dayLabel,
+		dayChip,
+		when,
+		date,
+		dateTime,
+		weekday
+	};
+}
+//#endregion
+export { createClock };
+
+//# sourceMappingURL=clock.mjs.map