@medalsocial/booking 0.0.0-placeholder.0 → 0.2.0

package/dist/core/party-slots.mjs

@@ -0,0 +1,229 @@
+import { createClock } from "./clock.mjs";
+import { visitKey } from "./visit.mjs";
+import { itemStartTimes } from "./machine.mjs";
+//#region src/core/party-slots.ts
+/**
+* Seating a family: which instants a whole party can actually be taken at, and
+* with whom.
+*
+* The engine answers «when is this ONE service free?» — one row per stylist per
+* instant, because `listSlots` returns a `resourceId` with every slot. Nothing
+* upstream answers «when can these two children be seen back to back?», and
+* nothing should: it is a question about a basket that only exists in this
+* wizard.
+*
+* Pure, and a sibling of `wizard-machine.ts` rather than part of it, for the
+* reason the machine states about itself — the search is where a family booking
+* goes wrong (a stylist who can only cut one of the two, a pair of times that
+* are an hour apart, the same stylist promised to both children at once), and
+* every one of those is provable without rendering anything.
+*
+* It imports `itemStartTimes` rather than restating the seating arithmetic:
+* step 4 submits with that function and the confirmation card reads it back, so
+* a search that laid the children out any other way would offer a slot the
+* submission then asked for at different times.
+*/
+/** The keys a basket's availability is fetched and stored under: each distinct
+* visit once, in basket order — the list the wizard asks the route for. */
+function slotKeysFor(items) {
+	return [...new Set(items.map((item) => visitKey(item)))];
+}
+/** `resource@instant`, the unit both searches ask about. */
+function seatKey(resourceId, startTs) {
+	return `${resourceId}@${startTs}`;
+}
+/**
+* The catalogue, indexed for the only question either search asks: is this
+* stylist free for this visit at this exact minute?
+*
+* Slots with no `resourceId` are dropped rather than treated as «anybody». The
+* wire type is nullable because `medal-client.ts` types every field the way the
+* serialiser emits it; a slot that arrived without one cannot be paired with a
+* second slot, since there would be no way to tell whether the pair is two
+* stylists or one stylist promised twice.
+*/
+function indexAvailability(slotsByService) {
+	const byVisit = /* @__PURE__ */ new Map();
+	const resourceOrder = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const [key, slots] of Object.entries(slotsByService)) {
+		const keys = byVisit.get(key) ?? /* @__PURE__ */ new Set();
+		for (const slot of slots) {
+			if (slot.resourceId === null) continue;
+			keys.add(seatKey(slot.resourceId, slot.startTs));
+			if (!seen.has(slot.resourceId)) {
+				seen.add(slot.resourceId);
+				resourceOrder.push(slot.resourceId);
+			}
+		}
+		byVisit.set(key, keys);
+	}
+	return {
+		free: (key, resourceId, startTs) => byVisit.get(key)?.has(seatKey(resourceId, startTs)) ?? false,
+		resourceOrder
+	};
+}
+/**
+* The instants the party could begin at: every time the FIRST child's visit is
+* free, with anybody, in ascending order and without repeats.
+*
+* The first child is the right anchor for both modes — sequential seats the
+* rest after them and parallel seats the rest alongside them — and starting
+* anywhere else would offer a visit whose opening line was never free.
+*
+* Deliberately does NOT re-filter the stylist-less slots that `indexAvailability`
+* drops. An instant only survives if some real stylist can be seated at it, and
+* that is the index's answer to give: a second copy of the rule here would be a
+* place for the two to disagree, and it would pass every test the index's own
+* guard already passes.
+*
+* Deduplicated, because two stylists free at the same minute are one offer to a
+* parent. Without the `Set` the same visit would be built once per stylist and
+* step 3 would draw the identical chip twice.
+*/
+function candidateStarts(items, slotsByService) {
+	const first = slotsByService[visitKey(items[0])] ?? [];
+	return [...new Set(first.map((slot) => slot.startTs))].sort((a, b) => a - b);
+}
+/**
+* One stylist for the whole visit.
+*
+* `every`, over every line item and not just the first: the report's example is
+* Sara doing Gutteklipp *and* Jenteklipp, and a search that only checked the
+* service the visitor happened to tap first would offer a stylist who cannot
+* cut the second child — a refusal the engine issues at submit, dressed up here
+* as a slot.
+*
+* The times come from `itemStartTimes`, so «contiguous» is enforced rather than
+* hoped for: the second child's slot has to exist at exactly the minute the
+* first one's service ends. 15:00 and 16:30 are two openings, not an hour.
+*/
+function seatSequentially(items, starts, index) {
+	for (const resourceId of index.resourceOrder) if (items.every((item, position) => index.free(visitKey(item), resourceId, starts[position]))) return items.map(() => resourceId);
+	return null;
+}
+/**
+* A different stylist per child, all at the same minute.
+*
+* Backtracking rather than a greedy pass, because greedy is wrong on the case
+* the salon actually has: three children where Sara is the only one who can
+* take the third, and Sara is also the first name on the list for the first
+* two. Handing her to child one and giving up leaves a seating that exists
+* unfound. A party is small — the salon's kids' services cap it at three, and
+* `maxPerBooking` caps it at whatever the salon seeds — so the search space is
+* trivial and correctness is free.
+*
+* `taken` is what makes the stylists distinct — the rule that one person cannot
+* cut two children at once, which no amount of availability data states on its
+* own, since one free slot is genuinely free for either child.
+*/
+function seatInParallel(items, starts, index) {
+	const taken = /* @__PURE__ */ new Set();
+	function assign(position) {
+		if (position === items.length) return [];
+		for (const resourceId of index.resourceOrder) {
+			if (taken.has(resourceId)) continue;
+			if (!index.free(visitKey(items[position]), resourceId, starts[position])) continue;
+			taken.add(resourceId);
+			const rest = assign(position + 1);
+			taken.delete(resourceId);
+			if (rest !== null) return [resourceId, ...rest];
+		}
+		return null;
+	}
+	return assign(0);
+}
+/**
+* Every instant the whole party can be taken at, in the mode the visitor chose.
+*
+* At most one slot per instant. Two stylists who could both take the same hour
+* back to back are one offer to a parent, not two identical chips — step 3 asks
+* «når passer det?», and the stylist question was step 2's.
+*/
+function findPartySlots(items, slotsByService, mode) {
+	if (items.length === 0) return [];
+	const index = indexAvailability(slotsByService);
+	const seat = mode === "parallel" ? seatInParallel : seatSequentially;
+	const found = [];
+	for (const startTs of candidateStarts(items, slotsByService)) {
+		const starts = itemStartTimes(items, startTs, mode);
+		const resourceIds = seat(items, starts, index);
+		if (resourceIds === null) continue;
+		found.push({
+			startTs,
+			mode,
+			seats: resourceIds.map((resourceId, position) => ({
+				startTs: starts[position],
+				resourceId
+			}))
+		});
+	}
+	return found;
+}
+/**
+* The report's rescue: «Ingen ledige timer rett etter hverandre torsdag – men
+* begge kan tas samtidig kl. 15:00.»
+*
+* Returns the earliest parallel slot on the day being looked at, and only when
+* the sequential search has genuinely found nothing on that same day. Offering
+* it alongside slots that do exist would be answering a question nobody asked;
+* withholding it when there are none is the empty day the report is trying to
+* prevent.
+*
+* The day is the salon's, not the viewer's — `clock.dayKey` rather than a date
+* string — for the reason every other clock face in this flow is: a 00:30 slot
+* belongs to the day the salon is open on, whatever UTC calls it.
+*/
+function partyAlternative(dayKey, args) {
+	const day = dayKey(args.dayTs);
+	if (args.sequential.some((slot) => dayKey(slot.startTs) === day)) return null;
+	return args.parallel.reduce((earliest, slot) => dayKey(slot.startTs) === day && (earliest === null || slot.startTs < earliest.startTs) ? slot : earliest, null);
+}
+/**
+* «Neste ledige» for a family: the earliest minute each stylist can take the
+* WHOLE party back to back.
+*
+* The single-service answer (`firstOpeningPerResource`, and the resources
+* route) is the first minute a stylist can take ONE child. Printed on a party's
+* stylist card it would quote a time the search on the time step then fails to
+* find for that stylist — the second child's slot need not be free straight
+* after. So this runs the very search `findPartySlots` runs once the visitor
+* picks the stylist (sequential, narrowed to that one person) and keeps the
+* first hit: the card and the day strip under it cannot disagree.
+*
+* Sequential only, deliberately. The parallel mode draws no stylist list — two
+* children at once are two people — so there is no card to hang an answer on.
+*
+* A stylist with no seating in the window gets no entry, the same «promise
+* nothing we do not know» rule the single-service line follows.
+*/
+function firstPartyStartPerResource(items, slotsByService) {
+	if (items.length === 0) return {};
+	const index = indexAvailability(slotsByService);
+	const earliest = {};
+	let left = index.resourceOrder.length;
+	for (const startTs of candidateStarts(items, slotsByService)) {
+		if (left === 0) break;
+		const starts = itemStartTimes(items, startTs, "sequential");
+		for (const resourceId of index.resourceOrder) {
+			if (resourceId in earliest) continue;
+			if (!items.every((item, position) => index.free(visitKey(item), resourceId, starts[position]))) continue;
+			earliest[resourceId] = startTs;
+			left -= 1;
+		}
+	}
+	return earliest;
+}
+/** The party search on this business's calendar. Only `partyAlternative` needs the clock. */
+function createPartySlots(config) {
+	const clock = createClock(config);
+	return {
+		findPartySlots,
+		firstPartyStartPerResource,
+		partyAlternative: (args) => partyAlternative(clock.dayKey, args)
+	};
+}
+//#endregion
+export { createPartySlots, findPartySlots, firstPartyStartPerResource, slotKeysFor };
+
+//# sourceMappingURL=party-slots.mjs.map

package/dist/core/party-slots.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"party-slots.mjs","names":[],"sources":["../../src/core/party-slots.ts"],"sourcesContent":["/**\n * Seating a family: which instants a whole party can actually be taken at, and\n * with whom.\n *\n * The engine answers «when is this ONE service free?» — one row per stylist per\n * instant, because `listSlots` returns a `resourceId` with every slot. Nothing\n * upstream answers «when can these two children be seen back to back?», and\n * nothing should: it is a question about a basket that only exists in this\n * wizard.\n *\n * Pure, and a sibling of `wizard-machine.ts` rather than part of it, for the\n * reason the machine states about itself — the search is where a family booking\n * goes wrong (a stylist who can only cut one of the two, a pair of times that\n * are an hour apart, the same stylist promised to both children at once), and\n * every one of those is provable without rendering anything.\n *\n * It imports `itemStartTimes` rather than restating the seating arithmetic:\n * step 4 submits with that function and the confirmation card reads it back, so\n * a search that laid the children out any other way would offer a slot the\n * submission then asked for at different times.\n */\n\nimport { type ClockConfig, createClock } from './clock';\nimport { itemStartTimes, type WizardItem, type WizardState } from './machine';\nimport type { BookingSlotDto } from './types';\nimport { visitKey } from './visit';\n\n/** One child's place in the visit: when they sit down, and with whom. */\nexport interface PartySeat {\n  startTs: number;\n  /**\n   * Never `null`, unlike `BookingSlotDto.resourceId`.\n   *\n   * «Første ledige» is an answer the engine can resolve for one booking, but a\n   * party slot is a claim about *particular* people — that one stylist has a\n   * clear hour, or that two different ones are free at the same minute. A seat\n   * that could not name its stylist could not make either claim.\n   */\n  resourceId: string;\n}\n\n/** A whole family, seated. */\nexport interface PartySlot {\n  /** When the visit starts — the first child sits down. */\n  startTs: number;\n  /** Which search produced it, so accepting the parallel alternative can also\n   * switch the mode the submission is seated with. */\n  mode: WizardState['partyMode'];\n  /** One per line item, in basket order. */\n  seats: PartySeat[];\n}\n\n/** Availability as the wizard collects it: one query per VISIT in the basket,\n * keyed by `visitKey` — a service id for a one-service visit, `a+b` for a\n * person having both. The server answers a visit as one list (spans as long as\n * the whole visit, on stylists who do every part of it), so it has to be stored\n * and read under the visit's key: the first service's own list would offer a\n * stylist who can cut but not wash. Two children sharing a visit share the\n * entry — which is exactly why the parallel search has to insist on distinct\n * stylists rather than trusting the lists to differ. */\nexport type SlotsByService = Readonly<Record<string, readonly BookingSlotDto[]>>;\n\n/** The keys a basket's availability is fetched and stored under: each distinct\n * visit once, in basket order — the list the wizard asks the route for. */\nexport function slotKeysFor(items: readonly WizardItem[]): string[] {\n  return [...new Set(items.map((item) => visitKey(item)))];\n}\n\n/** `resource@instant`, the unit both searches ask about. */\nfunction seatKey(resourceId: string, startTs: number): string {\n  return `${resourceId}@${startTs}`;\n}\n\n/**\n * The catalogue, indexed for the only question either search asks: is this\n * stylist free for this visit at this exact minute?\n *\n * Slots with no `resourceId` are dropped rather than treated as «anybody». The\n * wire type is nullable because `medal-client.ts` types every field the way the\n * serialiser emits it; a slot that arrived without one cannot be paired with a\n * second slot, since there would be no way to tell whether the pair is two\n * stylists or one stylist promised twice.\n */\nfunction indexAvailability(slotsByService: SlotsByService): {\n  free: (key: string, resourceId: string, startTs: number) => boolean;\n  resourceOrder: string[];\n} {\n  const byVisit = new Map<string, Set<string>>();\n  // First-encounter order across the whole catalogue: the tie-break when two\n  // stylists could both take the same slot. It follows whatever order the\n  // availability route returned, which is the engine's own resource order, so\n  // the wizard offers the same stylist twice in a row rather than shuffling\n  // under a re-render.\n  const resourceOrder: string[] = [];\n  const seen = new Set<string>();\n\n  for (const [key, slots] of Object.entries(slotsByService)) {\n    const keys = byVisit.get(key) ?? new Set<string>();\n    for (const slot of slots) {\n      if (slot.resourceId === null) continue;\n      keys.add(seatKey(slot.resourceId, slot.startTs));\n      if (!seen.has(slot.resourceId)) {\n        seen.add(slot.resourceId);\n        resourceOrder.push(slot.resourceId);\n      }\n    }\n    byVisit.set(key, keys);\n  }\n\n  return {\n    free: (key, resourceId, startTs) =>\n      byVisit.get(key)?.has(seatKey(resourceId, startTs)) ?? false,\n    resourceOrder,\n  };\n}\n\n/**\n * The instants the party could begin at: every time the FIRST child's visit is\n * free, with anybody, in ascending order and without repeats.\n *\n * The first child is the right anchor for both modes — sequential seats the\n * rest after them and parallel seats the rest alongside them — and starting\n * anywhere else would offer a visit whose opening line was never free.\n *\n * Deliberately does NOT re-filter the stylist-less slots that `indexAvailability`\n * drops. An instant only survives if some real stylist can be seated at it, and\n * that is the index's answer to give: a second copy of the rule here would be a\n * place for the two to disagree, and it would pass every test the index's own\n * guard already passes.\n *\n * Deduplicated, because two stylists free at the same minute are one offer to a\n * parent. Without the `Set` the same visit would be built once per stylist and\n * step 3 would draw the identical chip twice.\n */\nfunction candidateStarts(items: WizardItem[], slotsByService: SlotsByService): number[] {\n  const first = slotsByService[visitKey(items[0])] ?? [];\n  return [...new Set(first.map((slot) => slot.startTs))].sort((a, b) => a - b);\n}\n\n/**\n * One stylist for the whole visit.\n *\n * `every`, over every line item and not just the first: the report's example is\n * Sara doing Gutteklipp *and* Jenteklipp, and a search that only checked the\n * service the visitor happened to tap first would offer a stylist who cannot\n * cut the second child — a refusal the engine issues at submit, dressed up here\n * as a slot.\n *\n * The times come from `itemStartTimes`, so «contiguous» is enforced rather than\n * hoped for: the second child's slot has to exist at exactly the minute the\n * first one's service ends. 15:00 and 16:30 are two openings, not an hour.\n */\nfunction seatSequentially(\n  items: WizardItem[],\n  starts: number[],\n  index: ReturnType<typeof indexAvailability>\n): string[] | null {\n  for (const resourceId of index.resourceOrder) {\n    const fits = items.every((item, position) =>\n      index.free(visitKey(item), resourceId, starts[position])\n    );\n    if (fits) return items.map(() => resourceId);\n  }\n  return null;\n}\n\n/**\n * A different stylist per child, all at the same minute.\n *\n * Backtracking rather than a greedy pass, because greedy is wrong on the case\n * the salon actually has: three children where Sara is the only one who can\n * take the third, and Sara is also the first name on the list for the first\n * two. Handing her to child one and giving up leaves a seating that exists\n * unfound. A party is small — the salon's kids' services cap it at three, and\n * `maxPerBooking` caps it at whatever the salon seeds — so the search space is\n * trivial and correctness is free.\n *\n * `taken` is what makes the stylists distinct — the rule that one person cannot\n * cut two children at once, which no amount of availability data states on its\n * own, since one free slot is genuinely free for either child.\n */\nfunction seatInParallel(\n  items: WizardItem[],\n  starts: number[],\n  index: ReturnType<typeof indexAvailability>\n): string[] | null {\n  const taken = new Set<string>();\n\n  function assign(position: number): string[] | null {\n    if (position === items.length) return [];\n    for (const resourceId of index.resourceOrder) {\n      if (taken.has(resourceId)) continue;\n      if (!index.free(visitKey(items[position]), resourceId, starts[position])) continue;\n      taken.add(resourceId);\n      const rest = assign(position + 1);\n      taken.delete(resourceId);\n      if (rest !== null) return [resourceId, ...rest];\n    }\n    return null;\n  }\n\n  return assign(0);\n}\n\n/**\n * Every instant the whole party can be taken at, in the mode the visitor chose.\n *\n * At most one slot per instant. Two stylists who could both take the same hour\n * back to back are one offer to a parent, not two identical chips — step 3 asks\n * «når passer det?», and the stylist question was step 2's.\n */\nexport function findPartySlots(\n  items: WizardItem[],\n  slotsByService: SlotsByService,\n  mode: WizardState['partyMode']\n): PartySlot[] {\n  if (items.length === 0) return [];\n\n  const index = indexAvailability(slotsByService);\n  const seat = mode === 'parallel' ? seatInParallel : seatSequentially;\n  const found: PartySlot[] = [];\n\n  for (const startTs of candidateStarts(items, slotsByService)) {\n    const starts = itemStartTimes(items, startTs, mode);\n    const resourceIds = seat(items, starts, index);\n    if (resourceIds === null) continue;\n    found.push({\n      startTs,\n      mode,\n      seats: resourceIds.map((resourceId, position) => ({\n        startTs: starts[position],\n        resourceId,\n      })),\n    });\n  }\n\n  return found;\n}\n\n/**\n * The report's rescue: «Ingen ledige timer rett etter hverandre torsdag – men\n * begge kan tas samtidig kl. 15:00.»\n *\n * Returns the earliest parallel slot on the day being looked at, and only when\n * the sequential search has genuinely found nothing on that same day. Offering\n * it alongside slots that do exist would be answering a question nobody asked;\n * withholding it when there are none is the empty day the report is trying to\n * prevent.\n *\n * The day is the salon's, not the viewer's — `clock.dayKey` rather than a date\n * string — for the reason every other clock face in this flow is: a 00:30 slot\n * belongs to the day the salon is open on, whatever UTC calls it.\n */\nfunction partyAlternative(\n  dayKey: (ts: number) => string,\n  args: {\n    sequential: readonly PartySlot[];\n    parallel: readonly PartySlot[];\n    dayTs: number;\n  }\n): PartySlot | null {\n  const day = dayKey(args.dayTs);\n  if (args.sequential.some((slot) => dayKey(slot.startTs) === day)) return null;\n  return args.parallel.reduce<PartySlot | null>(\n    (earliest, slot) =>\n      dayKey(slot.startTs) === day && (earliest === null || slot.startTs < earliest.startTs)\n        ? slot\n        : earliest,\n    null\n  );\n}\n\n/**\n * «Neste ledige» for a family: the earliest minute each stylist can take the\n * WHOLE party back to back.\n *\n * The single-service answer (`firstOpeningPerResource`, and the resources\n * route) is the first minute a stylist can take ONE child. Printed on a party's\n * stylist card it would quote a time the search on the time step then fails to\n * find for that stylist — the second child's slot need not be free straight\n * after. So this runs the very search `findPartySlots` runs once the visitor\n * picks the stylist (sequential, narrowed to that one person) and keeps the\n * first hit: the card and the day strip under it cannot disagree.\n *\n * Sequential only, deliberately. The parallel mode draws no stylist list — two\n * children at once are two people — so there is no card to hang an answer on.\n *\n * A stylist with no seating in the window gets no entry, the same «promise\n * nothing we do not know» rule the single-service line follows.\n */\nexport function firstPartyStartPerResource(\n  items: WizardItem[],\n  slotsByService: SlotsByService\n): Record<string, number> {\n  if (items.length === 0) return {};\n\n  const index = indexAvailability(slotsByService);\n  const earliest: Record<string, number> = {};\n  let left = index.resourceOrder.length;\n\n  for (const startTs of candidateStarts(items, slotsByService)) {\n    if (left === 0) break;\n    const starts = itemStartTimes(items, startTs, 'sequential');\n    for (const resourceId of index.resourceOrder) {\n      if (resourceId in earliest) continue;\n      const fits = items.every((item, position) =>\n        index.free(visitKey(item), resourceId, starts[position])\n      );\n      if (!fits) continue;\n      earliest[resourceId] = startTs;\n      left -= 1;\n    }\n  }\n\n  return earliest;\n}\n\nexport interface PartySlots {\n  findPartySlots: typeof findPartySlots;\n  firstPartyStartPerResource: typeof firstPartyStartPerResource;\n  partyAlternative(args: {\n    sequential: readonly PartySlot[];\n    parallel: readonly PartySlot[];\n    dayTs: number;\n  }): PartySlot | null;\n}\n\n/** The party search on this business's calendar. Only `partyAlternative` needs the clock. */\nexport function createPartySlots(config: ClockConfig): PartySlots {\n  const clock = createClock(config);\n  return {\n    findPartySlots,\n    firstPartyStartPerResource,\n    partyAlternative: (args) => partyAlternative(clock.dayKey, args),\n  };\n}\n"],"mappings":"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"}

package/dist/core/paths.d.mts

@@ -0,0 +1,11 @@
+import { BookingConfig } from "./config.mjs";
+//#region src/core/paths.d.ts
+type PathsConfig = Pick<BookingConfig, 'paths'>;
+export interface Paths {
+  managePath(token: string): string;
+  isManagePath(pathname: string | null | undefined): boolean;
+  isPortalPath(pathname: string | null | undefined): boolean;
+}
+export declare function createPaths(config: PathsConfig): Paths;
+//#endregion
+//# sourceMappingURL=paths.d.mts.map

package/dist/core/paths.mjs

@@ -0,0 +1,56 @@
+//#region src/core/paths.ts
+/** The page that manages one booking. Encoded, because the token is opaque and
+* this is the only place that turns one into a URL. */
+function managePath(config, token) {
+	return `${config.paths.manage}/${encodeURIComponent(token)}`;
+}
+/** A path as a regex source, so a `.` in a configured path means a dot. */
+function escapeRegExp(path) {
+	return path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** `path` and everything below it, behind an optional `/xx` or `/xx-YY` locale segment. */
+function under(path) {
+	return new RegExp(`^(?:/[A-Za-z]{2}(?:-[A-Za-z]{2})?)?${escapeRegExp(path)}(?:/|$)`);
+}
+/**
+* Whether a pathname is a manage page — with or without a locale segment in
+* front of it.
+*
+* `localePrefix: 'as-needed'` means the site's one locale is unprefixed today,
+* so `/bestill/administrer/…` is what actually gets served. The optional
+* `/xx` or `/xx-YY` in front is for the day a second locale is added: the
+* tracker staying on for the Danish copy of this page would be the same leak
+* with a different first segment.
+*
+* `null` is what `usePathname` returns with no router above it, which cannot
+* happen for a client component under the App Router. It is answered `false`
+* rather than `true` so that a caller reading this as «is this the manage page»
+* is not told yes about a page it knows nothing about.
+*/
+function isManagePath(config, pathname) {
+	if (typeof pathname !== "string") return false;
+	return under(config.paths.manage).test(pathname);
+}
+/**
+* The portal (`paths.portal`, `/min-side` by default) and everything under it. The portal pages carry no credential in
+* the URL, but the dashboard renders each upcoming appointment's manage link —
+* a per-booking bearer token — into the DOM, and a third-party script mounted
+* on that page can read the DOM. So the analytics tracker treats the portal
+* exactly like the manage page: not loaded at all, rather than loaded and
+* asked not to look. Locale-prefixed forms are covered like `isManagePath`.
+*/
+function isPortalPath(config, pathname) {
+	if (typeof pathname !== "string" || config.paths.portal === null) return false;
+	return under(config.paths.portal).test(pathname);
+}
+function createPaths(config) {
+	return {
+		managePath: (token) => managePath(config, token),
+		isManagePath: (pathname) => isManagePath(config, pathname),
+		isPortalPath: (pathname) => isPortalPath(config, pathname)
+	};
+}
+//#endregion
+export { createPaths };
+
+//# sourceMappingURL=paths.mjs.map

package/dist/core/paths.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.mjs","names":[],"sources":["../../src/core/paths.ts"],"sourcesContent":["/**\n * Where a manage link points, spelled once.\n *\n * The path segment after this prefix is a live bearer credential: whoever holds\n * it can move or cancel that one appointment. Several things have to agree about\n * the shape of that URL — the wizard builds it, the manage page is served at it,\n * and `Analytics` has to recognise it in order to keep the tracker off — and\n * they are in three different layers of the app, which is exactly the sort of\n * spread where one of them drifts.\n *\n * Free of React, `server-only` and fetch on purpose: the root layout's\n * `Analytics` imports it, so it has to be safe in every bundle.\n */\n\nimport type { BookingConfig } from './config';\n\ntype PathsConfig = Pick<BookingConfig, 'paths'>;\n\n/** The page that manages one booking. Encoded, because the token is opaque and\n * this is the only place that turns one into a URL. */\nfunction managePath(config: PathsConfig, token: string): string {\n  return `${config.paths.manage}/${encodeURIComponent(token)}`;\n}\n\n/** A path as a regex source, so a `.` in a configured path means a dot. */\nfunction escapeRegExp(path: string): string {\n  return path.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\n/** `path` and everything below it, behind an optional `/xx` or `/xx-YY` locale segment. */\nfunction under(path: string): RegExp {\n  return new RegExp(`^(?:/[A-Za-z]{2}(?:-[A-Za-z]{2})?)?${escapeRegExp(path)}(?:/|$)`);\n}\n\n/**\n * Whether a pathname is a manage page — with or without a locale segment in\n * front of it.\n *\n * `localePrefix: 'as-needed'` means the site's one locale is unprefixed today,\n * so `/bestill/administrer/…` is what actually gets served. The optional\n * `/xx` or `/xx-YY` in front is for the day a second locale is added: the\n * tracker staying on for the Danish copy of this page would be the same leak\n * with a different first segment.\n *\n * `null` is what `usePathname` returns with no router above it, which cannot\n * happen for a client component under the App Router. It is answered `false`\n * rather than `true` so that a caller reading this as «is this the manage page»\n * is not told yes about a page it knows nothing about.\n */\nfunction isManagePath(config: PathsConfig, pathname: string | null | undefined): boolean {\n  if (typeof pathname !== 'string') return false;\n  return under(config.paths.manage).test(pathname);\n}\n\n/**\n * The portal (`paths.portal`, `/min-side` by default) and everything under it. The portal pages carry no credential in\n * the URL, but the dashboard renders each upcoming appointment's manage link —\n * a per-booking bearer token — into the DOM, and a third-party script mounted\n * on that page can read the DOM. So the analytics tracker treats the portal\n * exactly like the manage page: not loaded at all, rather than loaded and\n * asked not to look. Locale-prefixed forms are covered like `isManagePath`.\n */\nfunction isPortalPath(config: PathsConfig, pathname: string | null | undefined): boolean {\n  if (typeof pathname !== 'string' || config.paths.portal === null) return false;\n  return under(config.paths.portal).test(pathname);\n}\n\nexport interface Paths {\n  managePath(token: string): string;\n  isManagePath(pathname: string | null | undefined): boolean;\n  isPortalPath(pathname: string | null | undefined): boolean;\n}\n\nexport function createPaths(config: PathsConfig): Paths {\n  return {\n    managePath: (token) => managePath(config, token),\n    isManagePath: (pathname) => isManagePath(config, pathname),\n    isPortalPath: (pathname) => isPortalPath(config, pathname),\n  };\n}\n"],"mappings":";;;AAoBA,SAAS,WAAW,QAAqB,OAAuB;CAC9D,OAAO,GAAG,OAAO,MAAM,OAAO,GAAG,mBAAmB,KAAK;AAC3D;;AAGA,SAAS,aAAa,MAAsB;CAC1C,OAAO,KAAK,QAAQ,uBAAuB,MAAM;AACnD;;AAGA,SAAS,MAAM,MAAsB;CACnC,OAAO,IAAI,OAAO,sCAAsC,aAAa,IAAI,EAAE,QAAQ;AACrF;;;;;;;;;;;;;;;;AAiBA,SAAS,aAAa,QAAqB,UAA8C;CACvF,IAAI,OAAO,aAAa,UAAU,OAAO;CACzC,OAAO,MAAM,OAAO,MAAM,MAAM,CAAC,CAAC,KAAK,QAAQ;AACjD;;;;;;;;;AAUA,SAAS,aAAa,QAAqB,UAA8C;CACvF,IAAI,OAAO,aAAa,YAAY,OAAO,MAAM,WAAW,MAAM,OAAO;CACzE,OAAO,MAAM,OAAO,MAAM,MAAM,CAAC,CAAC,KAAK,QAAQ;AACjD;AAQA,SAAgB,YAAY,QAA4B;CACtD,OAAO;EACL,aAAa,UAAU,WAAW,QAAQ,KAAK;EAC/C,eAAe,aAAa,aAAa,QAAQ,QAAQ;EACzD,eAAe,aAAa,aAAa,QAAQ,QAAQ;CAC3D;AACF"}

package/dist/core/phone.d.mts

@@ -0,0 +1,17 @@
+import { BookingConfig } from "./config.mjs";
+//#region src/core/phone.d.ts
+/** `22 33 44 55` → `tel:22334455`. Spaces are typography; a phone dials digits. */
+export declare function telHref(phone: string): string;
+export interface Phone {
+  readonly country: string;
+  /** `strict` only for a country with a built-in rule set (`NO` in 0.x). */
+  readonly validate: 'strict' | 'loose';
+  telHref(phone: string): string;
+  /** What the details step submits, out of what the visitor typed. */
+  nationalDigits(value: string): string;
+  /** Whether the typed value is plausibly a number for this country. */
+  looksValid(value: string): boolean;
+}
+export declare function createPhone(config: Pick<BookingConfig, 'phone'>): Phone;
+//#endregion
+//# sourceMappingURL=phone.d.mts.map

package/dist/core/phone.mjs

@@ -0,0 +1,58 @@
+//#region src/core/phone.ts
+/** `22 33 44 55` → `tel:22334455`. Spaces are typography; a phone dials digits. */
+function telHref(phone) {
+	return `tel:${phone.replace(/\s/g, "")}`;
+}
+/**
+* Norway, the one strict rule set.
+*
+* The contact is deduplicated on this number, so «400 00 000» and
+* «+4740000000» from one parent must not become two families in the CRM.
+* Spacing goes, and so does a country code they pasted in on top of the `+47`
+* the field already shows.
+*
+* Only `+47` and `0047` are stripped, never a bare leading `47`: `47 12 34 56`
+* is an ordinary eight-digit Norwegian number, and taking the first two digits
+* off it would submit somebody else's phone.
+*/
+function norwegianDigits(value) {
+	return value.replace(/[\s()-]/g, "").replace(/^(?:\+47|0047)/, "");
+}
+/**
+* Eight digits, and nothing about which digit comes first.
+*
+* A claim about length, so a rule about length: requiring a leading 4 or 9
+* would be a *mobile* rule, and would answer a parent who typed a landline by
+* telling them a digit was missing when eight were present.
+*/
+function looksNorwegian(value) {
+	return /^\d{8}$/.test(norwegianDigits(value));
+}
+/** Anywhere else: separators go, a leading `+` stays, and 6–15 digits is E.164-ish. */
+function looseDigits(value) {
+	return value.replace(/[\s().-]/g, "");
+}
+function looksE164ish(value) {
+	return /^\+?\d{6,15}$/.test(looseDigits(value));
+}
+function createPhone(config) {
+	const { country } = config.phone;
+	if (country === "NO" && config.phone.validate === "strict") return {
+		country,
+		validate: "strict",
+		telHref,
+		nationalDigits: norwegianDigits,
+		looksValid: looksNorwegian
+	};
+	return {
+		country,
+		validate: "loose",
+		telHref,
+		nationalDigits: looseDigits,
+		looksValid: looksE164ish
+	};
+}
+//#endregion
+export { createPhone, telHref };
+
+//# sourceMappingURL=phone.mjs.map

package/dist/core/phone.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"phone.mjs","names":[],"sources":["../../src/core/phone.ts"],"sourcesContent":["/**\n * The booking flow's \"never a dead end\" affordances hand the visitor to the\n * telephone: a service the business does not take online, a slot inside the\n * lead time, a fully-booked day, a change asked for inside the cancellation\n * window. They all dial the same number, so they all build the link the same\n * way — one rule, in one place.\n *\n * The number itself is always a prop (`config.contact.phone`), and may be\n * missing, so every one of those sentences also has an unlinked form: a `tel:`\n * that dials nothing looks like an offer and fails in the visitor's hand.\n */\n\nimport type { BookingConfig } from './config';\n\n/** `22 33 44 55` → `tel:22334455`. Spaces are typography; a phone dials digits. */\nexport function telHref(phone: string): string {\n  return `tel:${phone.replace(/\\s/g, '')}`;\n}\n\nexport interface Phone {\n  readonly country: string;\n  /** `strict` only for a country with a built-in rule set (`NO` in 0.x). */\n  readonly validate: 'strict' | 'loose';\n  telHref(phone: string): string;\n  /** What the details step submits, out of what the visitor typed. */\n  nationalDigits(value: string): string;\n  /** Whether the typed value is plausibly a number for this country. */\n  looksValid(value: string): boolean;\n}\n\n/**\n * Norway, the one strict rule set.\n *\n * The contact is deduplicated on this number, so «400 00 000» and\n * «+4740000000» from one parent must not become two families in the CRM.\n * Spacing goes, and so does a country code they pasted in on top of the `+47`\n * the field already shows.\n *\n * Only `+47` and `0047` are stripped, never a bare leading `47`: `47 12 34 56`\n * is an ordinary eight-digit Norwegian number, and taking the first two digits\n * off it would submit somebody else's phone.\n */\nfunction norwegianDigits(value: string): string {\n  return value.replace(/[\\s()-]/g, '').replace(/^(?:\\+47|0047)/, '');\n}\n\n/**\n * Eight digits, and nothing about which digit comes first.\n *\n * A claim about length, so a rule about length: requiring a leading 4 or 9\n * would be a *mobile* rule, and would answer a parent who typed a landline by\n * telling them a digit was missing when eight were present.\n */\nfunction looksNorwegian(value: string): boolean {\n  return /^\\d{8}$/.test(norwegianDigits(value));\n}\n\n/** Anywhere else: separators go, a leading `+` stays, and 6–15 digits is E.164-ish. */\nfunction looseDigits(value: string): string {\n  return value.replace(/[\\s().-]/g, '');\n}\n\nfunction looksE164ish(value: string): boolean {\n  return /^\\+?\\d{6,15}$/.test(looseDigits(value));\n}\n\nexport function createPhone(config: Pick<BookingConfig, 'phone'>): Phone {\n  const { country } = config.phone;\n  if (country === 'NO' && config.phone.validate === 'strict') {\n    return {\n      country,\n      validate: 'strict',\n      telHref,\n      nationalDigits: norwegianDigits,\n      looksValid: looksNorwegian,\n    };\n  }\n  return {\n    country,\n    validate: 'loose',\n    telHref,\n    nationalDigits: looseDigits,\n    looksValid: looksE164ish,\n  };\n}\n"],"mappings":";;AAeA,SAAgB,QAAQ,OAAuB;CAC7C,OAAO,OAAO,MAAM,QAAQ,OAAO,EAAE;AACvC;;;;;;;;;;;;;AAyBA,SAAS,gBAAgB,OAAuB;CAC9C,OAAO,MAAM,QAAQ,YAAY,EAAE,CAAC,CAAC,QAAQ,kBAAkB,EAAE;AACnE;;;;;;;;AASA,SAAS,eAAe,OAAwB;CAC9C,OAAO,UAAU,KAAK,gBAAgB,KAAK,CAAC;AAC9C;;AAGA,SAAS,YAAY,OAAuB;CAC1C,OAAO,MAAM,QAAQ,aAAa,EAAE;AACtC;AAEA,SAAS,aAAa,OAAwB;CAC5C,OAAO,gBAAgB,KAAK,YAAY,KAAK,CAAC;AAChD;AAEA,SAAgB,YAAY,QAA6C;CACvE,MAAM,EAAE,YAAY,OAAO;CAC3B,IAAI,YAAY,QAAQ,OAAO,MAAM,aAAa,UAChD,OAAO;EACL;EACA,UAAU;EACV;EACA,gBAAgB;EAChB,YAAY;CACd;CAEF,OAAO;EACL;EACA,UAAU;EACV;EACA,gBAAgB;EAChB,YAAY;CACd;AACF"}

package/dist/core/portal/cookies.d.mts

@@ -0,0 +1,29 @@
+//#region src/core/portal/cookies.d.ts
+/**
+ * The cookie jar the portal helpers read and write, as an interface.
+ *
+ * `/core` imports no framework, so the helpers that touch cookies take the jar
+ * from a function the caller supplies. `/next` (P4) passes Next's own
+ * `cookies()` from `next/headers`; a test passes an in-memory jar.
+ */
+export interface CookieAttributes {
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: 'lax' | 'strict' | 'none';
+  path?: string;
+  maxAge?: number;
+  expires?: Date;
+}
+export interface CookieJar {
+  get(name: string): {
+    value?: string;
+  } | undefined;
+  set(name: string, value: string, options?: CookieAttributes): unknown;
+  delete(options: {
+    name: string;
+  } & CookieAttributes): unknown;
+}
+/** Where the jar for THIS request comes from — Next's `cookies`, or a test double. */
+export type CookieSource = () => CookieJar | Promise<CookieJar>;
+//#endregion
+//# sourceMappingURL=cookies.d.mts.map

package/dist/core/portal/dto.d.mts

@@ -0,0 +1,140 @@
+import { BookingConfig } from "../config.mjs";
+import { PortalBooking, PortalBookingStatus, PortalProfile } from "@medalsocial/sdk";
+//#region src/core/portal/dto.d.ts
+/**
+ * One child on the profile — a PERSON now, not a name (SP10).
+ *
+ * `personId` is what makes a child something this site can point at: the id
+ * of the `contactPersons` row Medal keeps, stable across a rename through
+ * `/me/persons/{id}`, and the key a past booking carries as
+ * `booked_for_person_id`. It is `null` only against a Medal that sent neither
+ * a `person_id` on the family entry nor one unambiguous person of that name
+ * and year — the site then falls back to what it did before persons existed.
+ *
+ * `birthMonth`, `notes` («Notat til frisøren») and `preferredResourceId`
+ * («Fast frisør») are SP10's portal-editable details; each is `null` when
+ * unset AND when Medal predates them — see `personDetails` on the profile for
+ * telling the two apart.
+ */
+export interface PortalFamilyMemberDto {
+  personId: string | null;
+  name: string;
+  birthYear: number;
+  birthMonth: number | null;
+  notes: string | null;
+  preferredResourceId: string | null;
+}
+/**
+ * The bransjemal preset's words for who a booking is for — «Barn» for a
+ * children's salon, «Familie» wherever the fallback still applies. `person` is the
+ * singular a future per-row label would use; only `persons` is read today.
+ */
+export interface PortalLabels {
+  person: string;
+  persons: string;
+}
+export interface PortalProfileDto {
+  contactId: string;
+  email: string;
+  firstName: string | null;
+  lastName: string | null;
+  phone: string | null;
+  family: PortalFamilyMemberDto[];
+  /**
+   * Whether this Medal speaks SP10 persons — birth month, notes and preferred
+   * stylist on each child, and the `/me/persons` endpoints that edit them.
+   * Read off the wire (the fields are present, `null` or not), so the editor
+   * offers the extra fields only where they can be saved. `false` also for a
+   * profile with no persons at all, where there is nothing to read it off;
+   * the person actions still try the endpoints and fall back on a 404.
+   */
+  personDetails: boolean;
+  marketingConsent: boolean;
+  labels?: PortalLabels;
+  /**
+   * Whether the parent's Vipps account is linked to this profile — present
+   * only when Medal says (`vipps_linked`, with the «Koble til Vipps» routes).
+   * ABSENT against a Medal that predates them, and then Min side → Profil
+   * draws no Vipps row: a button whose route does not exist is a dead end.
+   */
+  vippsLinked?: boolean;
+}
+export interface PortalBookingDto {
+  bookingId: string;
+  status: PortalBookingStatus;
+  startTs: number;
+  endTs: number;
+  serviceId: string | null;
+  serviceName: string | null;
+  resourceId: string | null;
+  resourceName: string | null;
+  bookedForName: string | null;
+  /**
+   * Who the visit was for, by id — the `person_id` of one of the parent's
+   * children, or `null` for a visit for the parent themselves, one made before
+   * persons existed, or a Medal that does not send it yet (SP10). This is the
+   * key «Samme som sist» joins on; the name is only the fallback.
+   */
+  bookedForPersonId: string | null;
+  /** The birth year and month frozen onto the booking, when Medal sends them. */
+  bookedForBirthYear: number | null;
+  bookedForBirthMonth: number | null;
+  amountOre: number | null;
+  notes: string | null;
+  /**
+   * Where this booking is managed, or `null` when Medal issued no token for it
+   * — a cancelled or completed row, or one made over the counter. The token
+   * itself is deliberately not on this object; see the module comment.
+   */
+  managePath: string | null;
+}
+/** 1–12, or `null` for anything else — absent, `null`, or nonsense. */
+export declare function monthOrNull(value: unknown): number | null;
+/**
+ * Nulls stay nulls. The page decides what a missing surname or phone number
+ * reads as, and a `''` here would make «not given» and «given as blank»
+ * indistinguishable to the form that edits them.
+ */
+export declare function toPortalProfileDto(profile: PortalProfile): PortalProfileDto;
+/**
+ * What a «Bestill igjen» card carries: enough to prefill the wizard's three
+ * questions (`?service&stylist&who`) and the two names it shows on the card.
+ * No ids the wizard cannot vouch for are trusted downstream — `applyPrefill`
+ * ignores a service or stylist the catalogue no longer lists — so this does
+ * not need to check them either.
+ */
+export interface RebookSuggestion {
+  serviceId: string;
+  serviceName: string | null;
+  resourceId: string | null;
+  resourceName: string | null;
+  bookedForName: string | null;
+}
+/**
+ * The haircuts worth offering again, most recent first, at most `max` of them.
+ *
+ * Distinct by (service, stylist, child): a family that books the same cut for
+ * the same child with the same stylist every six weeks has ONE habit, not ten,
+ * and ten identical cards would push the second child's cut off the list.
+ * «Any stylist» (`resourceId: null`) is its own key — a parent who never
+ * chose is offered the same non-choice, not the stylist they happened to get.
+ *
+ * Only `completed` rows: a cancelled or no-show booking is not a haircut that
+ * happened, and a pending or confirmed one is upcoming, not history — offering
+ * to book it again would be offering a duplicate. A row whose `serviceId` is
+ * null has nothing to link to and is skipped rather than rendered as a card
+ * that opens the wizard on step 1.
+ *
+ * Sorts a copy: the caller's `past` array is rendered in its own order.
+ */
+export declare function rebookSuggestions(past: PortalBookingDto[], max?: number): RebookSuggestion[];
+export interface PortalDto {
+  toPortalProfileDto: typeof toPortalProfileDto;
+  /** The booking, with its manage token turned into this site's manage PATH (`paths.manage`). */
+  toPortalBookingDto(booking: PortalBooking): PortalBookingDto;
+  rebookSuggestions: typeof rebookSuggestions;
+  monthOrNull: typeof monthOrNull;
+}
+export declare function createPortalDto(config: Pick<BookingConfig, 'paths'>): PortalDto;
+//#endregion
+//# sourceMappingURL=dto.d.mts.map