@evinvest/kitstart 0.9.0 → 0.11.0

package/dist/core/lead-capture-text.js

@@ -1,4 +1,65 @@
+const FR_FLOW = {
+    priceTitle: "Votre prix",
+    pricePending: "Répondez aux questions pour voir le prix.",
+    priceNote: "Prix TTC pour ces réponses, payé après la prestation.",
+    priceBase: "Prix de base",
+    priceRounding: "Arrondi",
+    priceMinimum: "Minimum de prestation",
+    bookSubmit: "Réserver",
+    sentPrice: "Demande enregistrée au prix de {price}.",
+    slotCallback: "Nous vous rappelons pour fixer le créneau.",
+    priceChanged: "Le prix a changé : {price} au lieu de {shown}. Confirmez pour envoyer votre demande à ce prix.",
+    priceChangedGeneric: "Le prix a changé depuis l’affichage de la page. Vérifiez le nouveau prix et confirmez.",
+    bookCta: "Choisir un créneau",
+    bookPhoneHint: "Indiquez le même numéro de téléphone en réservant : il relie le créneau à votre demande.",
+    bookNote: "Sinon, nous vous rappelons pour fixer le créneau.",
+    booked: "Créneau réservé. Merci !",
+    preferTitle: "Une préférence pour le créneau ? (facultatif)",
+    preferDay: "Jour",
+    preferPart: "Moment de la journée",
+    partMorning: "Matin",
+    partAfternoon: "Après-midi",
+    partEvening: "Soir",
+    preferSubmit: "Envoyer ma préférence",
+    preferSent: "Préférence notée : nous en tenons compte en vous rappelant.",
+    preferFailed: "Votre préférence n’a pas pu être envoyée. Nous vous rappelons quand même pour fixer le créneau.",
+    photosTitle: "Envoyez des photos",
+    photosLede: "Pour ce besoin, quelques photos nous permettent de vous donner un prix juste.",
+    photosCta: "Envoyer des photos sur WhatsApp",
+    photosMessage: "Bonjour, voici des photos pour : {need}.",
+};
+const EN_FLOW = {
+    priceTitle: "Your price",
+    pricePending: "Answer the questions to see the price.",
+    priceNote: "Price incl. VAT for these answers, paid after the job.",
+    priceBase: "Base price",
+    priceRounding: "Rounding",
+    priceMinimum: "Minimum charge",
+    bookSubmit: "Book",
+    sentPrice: "Request saved at {price}.",
+    slotCallback: "We will call you to set the slot.",
+    priceChanged: "The price has changed: {price} instead of {shown}. Confirm to send your request at this price.",
+    priceChangedGeneric: "The price has changed since the page was shown. Check the new price and confirm.",
+    bookCta: "Pick a slot",
+    bookPhoneHint: "Enter the same phone number when you book: it links the slot to your request.",
+    bookNote: "Otherwise we will call you to set the slot.",
+    booked: "Slot booked. Thank you!",
+    preferTitle: "A preferred slot? (optional)",
+    preferDay: "Day",
+    preferPart: "Time of day",
+    partMorning: "Morning",
+    partAfternoon: "Afternoon",
+    partEvening: "Evening",
+    preferSubmit: "Send my preference",
+    preferSent: "Noted: we will keep it in mind when we call.",
+    preferFailed: "Your preference could not be sent. We will still call you to set the slot.",
+    photosTitle: "Send photos",
+    photosLede: "For this job, a few photos let us give you a fair price.",
+    photosCta: "Send photos on WhatsApp",
+    photosMessage: "Hello, here are photos for: {need}.",
+};
 const FR = {
+    ...FR_FLOW,
     title: "Recevoir un prix",
     lede: "Réponse rapide, sans engagement.",
     needLabel: "Votre besoin",
@@ -14,7 +75,7 @@ const FR = {
     fieldInvalid: "Vérifiez ce champ.",
     formInvalid: "Votre demande n’a pas pu être envoyée. Vérifiez le formulaire.",
     sending: "Envoi…",
-    networkError: "Pas de connexion : votre demande n’est pas partie. Vérifiez le réseau et réessayez.",
+    networkError: "Pas de réponse du serveur. Vérifiez votre connexion et réessayez : votre demande ne sera pas envoyée deux fois.",
     timeoutError: "Le serveur ne répond pas. Réessayez : votre demande ne sera pas envoyée deux fois.",
     retry: "Réessayer",
     nameLabel: "Nom",
@@ -37,6 +98,7 @@ const FR = {
     honeypotLabel: "Site web",
 };
 const EN = {
+    ...EN_FLOW,
     title: "Get a price",
     lede: "A quick answer, no commitment.",
     needLabel: "What you need",
@@ -52,7 +114,7 @@ const EN = {
     fieldInvalid: "Check this field.",
     formInvalid: "Your request could not be sent. Check the form.",
     sending: "Sending…",
-    networkError: "No connection: your request was not sent. Check the network and try again.",
+    networkError: "No answer from the server. Check your connection and try again: your request will not be sent twice.",
     timeoutError: "The server is not answering. Try again: your request will not be sent twice.",
     retry: "Try again",
     nameLabel: "Name",
@@ -75,3 +137,14 @@ const EN = {
     honeypotLabel: "Website",
 };
 export const LEAD_CAPTURE_TEXT = { fr: FR, en: EN };
+/** The flows' words for a page: the brand's, else the kit's in its language (English for `en*`, French otherwise). */
+export function flowTextOf(text, locale) {
+    const kit = locale.startsWith("en") ? EN_FLOW : FR_FLOW;
+    const out = { ...kit };
+    for (const key of Object.keys(kit)) {
+        const own = text[key];
+        if (own !== undefined)
+            out[key] = own;
+    }
+    return out;
+}

package/dist/core/lead.d.ts

@@ -9,6 +9,8 @@
  * `LeadSchema.wire` names the posted fields (a page cached before a rename
  * still delivers) — both deliberate departures from the first design.
  */
+import type { LeadFlow, LeadFlows } from "./pricing/flow.js";
+import type { PricingInputs } from "./pricing/model.js";
 /** Why a submission was kept but not acted on. `null` is a clean lead. */
 export type SpamVerdict = "honeypot" | "too-fast" | "rate-limited";
 /**
@@ -73,6 +75,13 @@ export interface LeadSchema<S extends string> {
      * number as typed.
      */
     mobileFormat?: "typed" | "e164";
+    /**
+     * How each need is sold (`quote` | `estimate` | `fixed`); a need left out
+     * is a `quote`. The form and the server read the same map, and a need runs
+     * its flow only when the price list prices it that way (`flowOf`) — so a
+     * flow the brand has not switched on is never run by a posted field.
+     */
+    flows?: LeadFlows;
 }
 /**
  * How the lead was asked for: the quote form, or "call me back" — the form cut
@@ -100,6 +109,39 @@ export declare const SUBMISSION_FIELD = "submission_id";
 export declare const SUBMISSION_ID: RegExp;
 /** The query a refused submission is sent back to the form with: `?lead_error=<field>`. */
 export declare const LEAD_ERROR_PARAM = "lead_error";
+/** A refusal the server sent back: which of the card's forms, and the field it is about. */
+export interface LeadError {
+    channel: LeadChannel;
+    field: string;
+}
+/** What a refused field may be named: a slug, never markup. */
+export declare const LEAD_ERROR_FIELD: RegExp;
+/**
+ * The query naming where a refusal lands — the anchor the 303 points at,
+ * `<card>` or `<card>-callback` — because the fragment never reaches the
+ * server, and a page may draw more than one card.
+ */
+export declare const LEAD_CARD_PARAM = "lead_card";
+/** A refusal as a page reads it from its query: the card it is for, when the URL names one. */
+export interface PageLeadError extends LeadError {
+    card: string | null;
+}
+/**
+ * The refusal a 303 brought the visitor back with, read from a page's
+ * `searchParams` on the server — `LeadCapture`'s `initialError`, so the card
+ * says why without a script. Only a page that reads its query can: one built
+ * for ISR does not, and there the card's script says it. `card` is the anchor
+ * the route named (`lead_card`), which each card matches against its own id;
+ * a URL from before it was named leaves it `null`, and then the consent is
+ * the callback's and every other field the form's.
+ */
+export declare function leadErrorOf(searchParams: Readonly<Record<string, string | readonly string[] | undefined>>): PageLeadError | null;
+/**
+ * The refusal card `id` draws: one whose `card` is this card's form or its
+ * callback, there; one naming no card (an older URL), as it reads; one for
+ * another card, none.
+ */
+export declare function leadErrorFor(error: LeadError | PageLeadError | null, id: string): LeadError | null;
 /**
  * The card's id, posted so a refusal lands back on it (`#devis`, not a
  * hard-coded `#quote`). Only a slug is ever echoed into the redirect.
@@ -139,6 +181,25 @@ export interface Lead {
      * Absent on a plain post, which has no script to mint one.
      */
     submissionId?: string;
+    /**
+     * How the need was sold, when the brand sells by flow (`LeadSchema.flows`)
+     * and the lead came through the form; absent otherwise — a callback, or a
+     * lead from before the field existed.
+     */
+    flow?: LeadFlow;
+    /** Only on an `estimate` or `fixed` lead: the price the server computed. */
+    price?: LeadPrice;
+}
+/**
+ * The price a lead was taken at — the server's own number, from the posted
+ * answers, never a posted amount — and the model it came from.
+ */
+export interface LeadPrice {
+    cents: number;
+    /** The model's `validFrom`, `YYYY-MM-DD`. */
+    validFrom: string;
+    /** An estimate's answers, input id → option id; absent for a fixed price. */
+    inputs?: PricingInputs;
 }
 /** What the panel may be told of a suspected lead. */
 export type LeadSuspect = "rate_limited" | "too_fast";
@@ -154,7 +215,7 @@ export declare function channelOf(lead: Pick<Lead, "channel">): LeadChannel;
  * What the form posted, before the funnel judges it: the consent is the
  * posted sentence, and the funnel stamps when it accepted it.
  */
-export type LeadCandidate = Omit<Lead, "spamVerdict" | "consent"> & {
+export type LeadCandidate = Omit<Lead, "spamVerdict" | "consent" | "flow" | "price"> & {
     consentText?: string;
 };
 /**
@@ -189,9 +250,10 @@ export interface LeadStore {
  * The lead schema's version, shared by every adapter: 1 the Rust server's
  * table (`job`, `zip`, `mobile`, `at`), 2 + the place, 3 + the spam verdict,
  * 4 + the brand's extras, 5 + the channel and the callback's consent, 6 + the
- * script's submission id, unique. Append only.
+ * script's submission id, unique, 7 + the flow and the price it was taken at.
+ * Append only.
  */
-export declare const LEAD_SCHEMA_VERSION = 6;
+export declare const LEAD_SCHEMA_VERSION = 7;
 /** A field is capped, not rejected: a long answer is still a customer. */
 export declare const MAX_FIELD = 200;
 /**

package/dist/core/lead.js

@@ -25,6 +25,49 @@ export const SUBMISSION_FIELD = "submission_id";
 export const SUBMISSION_ID = /^[A-Za-z0-9-]{16,64}$/;
 /** The query a refused submission is sent back to the form with: `?lead_error=<field>`. */
 export const LEAD_ERROR_PARAM = "lead_error";
+/** What a refused field may be named: a slug, never markup. */
+export const LEAD_ERROR_FIELD = /^[a-z][a-z0-9_]{0,31}$/;
+/**
+ * The query naming where a refusal lands — the anchor the 303 points at,
+ * `<card>` or `<card>-callback` — because the fragment never reaches the
+ * server, and a page may draw more than one card.
+ */
+export const LEAD_CARD_PARAM = "lead_card";
+const LEAD_CARD = /^[a-z0-9-]{1,80}$/;
+const first = (raw) => (typeof raw === "string" ? raw : raw?.[0]);
+/**
+ * The refusal a 303 brought the visitor back with, read from a page's
+ * `searchParams` on the server — `LeadCapture`'s `initialError`, so the card
+ * says why without a script. Only a page that reads its query can: one built
+ * for ISR does not, and there the card's script says it. `card` is the anchor
+ * the route named (`lead_card`), which each card matches against its own id;
+ * a URL from before it was named leaves it `null`, and then the consent is
+ * the callback's and every other field the form's.
+ */
+export function leadErrorOf(searchParams) {
+    const field = first(searchParams[LEAD_ERROR_PARAM]);
+    if (field === undefined || !LEAD_ERROR_FIELD.test(field))
+        return null;
+    const card = first(searchParams[LEAD_CARD_PARAM]);
+    return { channel: field === "consent" ? "callback" : "form", field, card: card !== undefined && LEAD_CARD.test(card) ? card : null };
+}
+/**
+ * The refusal card `id` draws: one whose `card` is this card's form or its
+ * callback, there; one naming no card (an older URL), as it reads; one for
+ * another card, none.
+ */
+export function leadErrorFor(error, id) {
+    if (!error)
+        return null;
+    const card = "card" in error ? error.card : null;
+    if (card === null)
+        return { channel: error.channel, field: error.field };
+    if (card === id)
+        return { channel: "form", field: error.field };
+    if (card === `${id}-callback`)
+        return { channel: "callback", field: error.field };
+    return null;
+}
 /**
  * The card's id, posted so a refusal lands back on it (`#devis`, not a
  * hard-coded `#quote`). Only a slug is ever echoed into the redirect.
@@ -70,9 +113,10 @@ export function channelOf(lead) {
  * The lead schema's version, shared by every adapter: 1 the Rust server's
  * table (`job`, `zip`, `mobile`, `at`), 2 + the place, 3 + the spam verdict,
  * 4 + the brand's extras, 5 + the channel and the callback's consent, 6 + the
- * script's submission id, unique. Append only.
+ * script's submission id, unique, 7 + the flow and the price it was taken at.
+ * Append only.
  */
-export const LEAD_SCHEMA_VERSION = 6;
+export const LEAD_SCHEMA_VERSION = 7;
 /** A field is capped, not rejected: a long answer is still a customer. */
 export const MAX_FIELD = 200;
 // C0 and C1 controls, DEL, and the Unicode line and paragraph separators.

package/dist/core/phone.d.ts

@@ -7,7 +7,9 @@
  * `0033 6 …`, a mobile typed without its trunk zero (`6 12 34 56 78`) — all
  * become `+33612345678`. Any other international number is a plausible E.164,
  * 8 to 15 digits after the `+`, compacted (`+44 7911 123456` →
- * `+447911123456`). Full-width digits read as digits; a run of one digit
+ * `+447911123456`) — and, for the plans a visitor here most often dials
+ * from (`NATIONAL_LENGTH`), as long as that plan's numbers are, so `+12345678`
+ * is not a number. Full-width digits read as digits; a run of one digit
  * (`00 00 00 00 00`, `06 66 66 66 66`) is a refusal to give a number, not one.
  */
 export declare function normalizePhone(raw: string): string | null;

package/dist/core/phone.js

@@ -1,3 +1,27 @@
+/**
+ * The national number's length, after the country code, for the plans the
+ * vertical's visitors most often come from — bounds wide enough for every
+ * real number (Germany and Italy vary by area), short of a library. A plan
+ * not listed keeps E.164's 8 to 15 digits in all.
+ */
+const NATIONAL_LENGTH = {
+    "1": [10, 10],
+    "32": [8, 9],
+    "34": [9, 9],
+    "39": [6, 11],
+    "41": [9, 9],
+    "44": [9, 10],
+    "49": [7, 13],
+};
+function fitsPlan(e164) {
+    const digits = e164.slice(1);
+    for (const code of [digits.slice(0, 1), digits.slice(0, 2)]) {
+        const bounds = NATIONAL_LENGTH[code];
+        if (bounds)
+            return digits.length - code.length >= bounds[0] && digits.length - code.length <= bounds[1];
+    }
+    return true;
+}
 /**
  * A phone number as the funnel reads it: E.164 when the typed value is a
  * number someone can be reached on, otherwise `null`.
@@ -7,7 +31,9 @@
  * `0033 6 …`, a mobile typed without its trunk zero (`6 12 34 56 78`) — all
  * become `+33612345678`. Any other international number is a plausible E.164,
  * 8 to 15 digits after the `+`, compacted (`+44 7911 123456` →
- * `+447911123456`). Full-width digits read as digits; a run of one digit
+ * `+447911123456`) — and, for the plans a visitor here most often dials
+ * from (`NATIONAL_LENGTH`), as long as that plan's numbers are, so `+12345678`
+ * is not a number. Full-width digits read as digits; a run of one digit
  * (`00 00 00 00 00`, `06 66 66 66 66`) is a refusal to give a number, not one.
  */
 export function normalizePhone(raw) {
@@ -27,7 +53,7 @@ export function normalizePhone(raw) {
             e164 = `+33${trunk[1]}`;
         else if (/^[1-9]\d{8}$/.test(s))
             e164 = `+33${s}`;
-        else if (/^\+[1-9]\d{7,14}$/.test(s))
+        else if (/^\+[1-9]\d{7,14}$/.test(s) && fitsPlan(s))
             e164 = s;
     }
     if (e164 === null)

package/dist/core/place/live.d.ts

@@ -1,3 +1,4 @@
+import type { BookingConfig, BookingRules } from "../booking/model.js";
 import type { Geo, OpeningHours, Place, PostalAddress, Rating, ServiceArea } from "./types.js";
 /**
  * The live half of a place, as `GET <source>/locations/<slug>` answers it.
@@ -16,12 +17,15 @@ export interface PlaceLive<L extends string> {
     serviceArea?: readonly ServiceArea[];
     hours?: readonly OpeningHours[];
     rating?: Rating;
+    /** Validated with the site's Cal.com hosts; one that does not validate is dropped, the baked one kept. */
+    booking?: BookingConfig;
 }
 /**
  * Drops what does not validate instead of failing the page on one bad field.
- * A landmark counts only when it is given in every one of `locales`.
+ * A landmark counts only when it is given in every one of `locales`; a
+ * `cal_com` booking only on one of `rules.calComHosts` (the site's).
  */
-export declare function parsePlaceLive<L extends string>(body: unknown, locales: readonly L[]): PlaceLive<L>;
+export declare function parsePlaceLive<L extends string>(body: unknown, locales: readonly L[], rules?: BookingRules): PlaceLive<L>;
 /**
  * The live fields over the baked ones. A service-area place takes none of the
  * storefront's: an address, a pin or a photo from the source would give it a

package/dist/core/place/live.js

@@ -1,3 +1,4 @@
+import { BookingConfigError, parseBookingConfig } from "../booking/validate.js";
 import { parseInstant } from "./rating.js";
 const DAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
 const TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
@@ -60,11 +61,24 @@ function landmark(v, locales) {
 function isComplete(record, locales) {
     return locales.every(locale => typeof record[locale] === "string");
 }
+function booking(v, rules) {
+    if (v === undefined || v === null)
+        return undefined;
+    try {
+        return parseBookingConfig(v, rules);
+    }
+    catch (error) {
+        if (error instanceof BookingConfigError)
+            return undefined;
+        throw error;
+    }
+}
 /**
  * Drops what does not validate instead of failing the page on one bad field.
- * A landmark counts only when it is given in every one of `locales`.
+ * A landmark counts only when it is given in every one of `locales`; a
+ * `cal_com` booking only on one of `rules.calComHosts` (the site's).
  */
-export function parsePlaceLive(body, locales) {
+export function parsePlaceLive(body, locales, rules = {}) {
     if (!isObject(body))
         throw new Error("live location: body is not an object");
     const live = {};
@@ -104,6 +118,9 @@ export function parsePlaceLive(body, locales) {
     const r = rating(body.rating);
     if (r)
         live.rating = r;
+    const b = booking(body.booking, rules);
+    if (b)
+        live.booking = b;
     return live;
 }
 /**
@@ -113,6 +130,7 @@ export function parsePlaceLive(body, locales) {
  */
 export function mergeLive(baked, live) {
     const front = baked.presence;
+    const booking = live.booking ?? baked.booking;
     return {
         ...baked,
         presence: front.kind === "storefront"
@@ -128,5 +146,6 @@ export function mergeLive(baked, live) {
         serviceArea: live.serviceArea ?? baked.serviceArea,
         hours: live.hours ?? baked.hours,
         rating: live.rating ?? baked.rating,
+        ...(booking ? { booking } : {}),
     };
 }

package/dist/core/place/types.d.ts

@@ -1,3 +1,4 @@
+import type { BookingConfig } from "../booking/model.js";
 /**
  * The place model. Three words, one each:
  *
@@ -79,6 +80,11 @@ export interface Place<L extends string> {
     hours: readonly OpeningHours[] | null;
     /** Live only. */
     rating: Rating | null;
+    /**
+     * How a priced lead's slot is set (`PlaceLive.booking`, the panel's place
+     * settings); absent → `DEFAULT_BOOKING`, a call (`bookingOf`).
+     */
+    booking?: BookingConfig;
 }
 /** The storefront half of a place, or `null` for a service-area business. */
 export declare function storefrontOf<L extends string>(place: Place<L>): Extract<Presence<L>, {

package/dist/core/place/types.js

@@ -1,16 +1,3 @@
-/**
- * The place model. Three words, one each:
- *
- * - **Place** — the aggregate: one point of the business, baked config merged
- *   with the live source;
- * - **Presence** — how the place exists for a visitor: a storefront with an
- *   address, or a service area with none;
- * - **ServiceArea** — where the van goes.
- *
- * A service-area business has no address *in the type*, so no builder can
- * render one for it by accident — schema.org, the map and the footer all have
- * to ask `presence.kind` first.
- */
 /** The storefront half of a place, or `null` for a service-area business. */
 export function storefrontOf(place) {
     return place.presence.kind === "storefront" ? place.presence : null;

package/dist/core/pricing/flow.d.ts

@@ -0,0 +1,27 @@
+import type { PricingInputs, PricingModel } from "./model.js";
+/**
+ * How a need is sold. `quote`: the price is uncertain, the lead asks for one.
+ * `estimate`: the price follows from a few enum answers, shown live, then a
+ * slot is booked. `fixed`: one price for a well-defined job, then a slot.
+ * Chosen per need, not per site: one brand can mix them.
+ */
+export type LeadFlow = "quote" | "estimate" | "fixed";
+export declare const LEAD_FLOWS: readonly LeadFlow[];
+/** A brand's flows by subject slug; a need left out is a `quote`. */
+export type LeadFlows = Readonly<Record<string, LeadFlow>>;
+/**
+ * The flow a need actually runs: the brand's, when the model prices the need
+ * that way — an `estimate` the model cannot price (a remote model without
+ * it, no model at all) is a `quote`, never a form with no price. The form and
+ * the server both ask this, so they agree on what was shown.
+ */
+export declare function flowOf(flows: LeadFlows | undefined, model: PricingModel | null, need: string | undefined): LeadFlow;
+/** The form field an estimate's input is posted under: `estimate_<input id>`. */
+export declare const ESTIMATE_FIELD_PREFIX = "estimate_";
+export declare const estimateField: (input: string) => string;
+/**
+ * The answers a form posted for the need's inputs — only those, and only
+ * slugs. Read by the server, which prices them itself: a posted amount, if
+ * any, is never read.
+ */
+export declare function readEstimateInputs(model: PricingModel, need: string, get: (field: string) => string | null): PricingInputs;

package/dist/core/pricing/flow.js

@@ -0,0 +1,37 @@
+import { PRICING_LIMITS } from "./model.js";
+export const LEAD_FLOWS = ["quote", "estimate", "fixed"];
+/**
+ * The flow a need actually runs: the brand's, when the model prices the need
+ * that way — an `estimate` the model cannot price (a remote model without
+ * it, no model at all) is a `quote`, never a form with no price. The form and
+ * the server both ask this, so they agree on what was shown.
+ */
+export function flowOf(flows, model, need) {
+    if (!flows || !model || need === undefined || !Object.hasOwn(flows, need))
+        return "quote";
+    const wanted = flows[need];
+    if (wanted === undefined || wanted === "quote")
+        return "quote";
+    const pricing = Object.hasOwn(model.needs, need) ? model.needs[need] : undefined;
+    return pricing?.kind === wanted ? wanted : "quote";
+}
+/** The form field an estimate's input is posted under: `estimate_<input id>`. */
+export const ESTIMATE_FIELD_PREFIX = "estimate_";
+export const estimateField = (input) => `${ESTIMATE_FIELD_PREFIX}${input}`;
+/**
+ * The answers a form posted for the need's inputs — only those, and only
+ * slugs. Read by the server, which prices them itself: a posted amount, if
+ * any, is never read.
+ */
+export function readEstimateInputs(model, need, get) {
+    const pricing = Object.hasOwn(model.needs, need) ? model.needs[need] : undefined;
+    if (pricing?.kind !== "estimate")
+        return {};
+    const out = {};
+    for (const id of pricing.inputs) {
+        const value = get(estimateField(id))?.trim();
+        if (value && PRICING_LIMITS.slug.test(value))
+            out[id] = value;
+    }
+    return out;
+}

package/dist/core/pricing/index.d.ts

@@ -0,0 +1,4 @@
+export { PRICING_CURRENCY, PRICING_FORMAT, PRICING_LIMITS, type AddOption, type DiscountOption, type MultiplyOption, type NeedPricing, type Price, type PriceLine, type PricingInput, type PricingInputKind, type PricingInputs, type PricingLabels, type PricingModel, } from "./model.js";
+export { CENTS_BUCKETS, centsBucket, mulBp, priceOf, roundTo } from "./price.js";
+export { labelOf, parsePricingModel, PricingModelError, pricingProblems, pricingProblemsFor } from "./validate.js";
+export { ESTIMATE_FIELD_PREFIX, estimateField, flowOf, LEAD_FLOWS, readEstimateInputs, type LeadFlow, type LeadFlows } from "./flow.js";

package/dist/core/pricing/index.js

@@ -0,0 +1,4 @@
+export { PRICING_CURRENCY, PRICING_FORMAT, PRICING_LIMITS, } from "./model.js";
+export { CENTS_BUCKETS, centsBucket, mulBp, priceOf, roundTo } from "./price.js";
+export { labelOf, parsePricingModel, PricingModelError, pricingProblems, pricingProblemsFor } from "./validate.js";
+export { ESTIMATE_FIELD_PREFIX, estimateField, flowOf, LEAD_FLOWS, readEstimateInputs } from "./flow.js";

package/dist/core/pricing/model.d.ts

@@ -0,0 +1,129 @@
+/**
+ * A brand's price list as data: what an `estimate` need costs for a set of
+ * enum inputs, and what a `fixed` need costs outright. JSON-serialisable on
+ * purpose — the panel edits it, serves it, and prices its own preview with a
+ * port of `priceOf` held to the same fixtures (`test/fixtures/pricing/`).
+ *
+ * Money is integer euro cents, TTC, throughout; a multiplier or a discount is
+ * in basis points (10 000 = ×1, 1 000 = 10 %), so no float ever reaches a
+ * stored or sent number.
+ */
+/** The model's format; a model of another format is refused whole. */
+export declare const PRICING_FORMAT = 1;
+/** The only currency a model may be in today: euros, all taxes included. */
+export declare const PRICING_CURRENCY = "EUR";
+/** A label per locale (`{ fr: "Studio", en: "Studio" }`); the page picks its own. */
+export type PricingLabels = Readonly<Record<string, string>>;
+/** One choice of an input: its slug, its words, and what it does to the price. */
+export interface AddOption {
+    id: string;
+    labels: PricingLabels;
+    /** Added to the base, in cents. */
+    addCents: number;
+}
+export interface MultiplyOption {
+    id: string;
+    labels: PricingLabels;
+    /** The subtotal times this, in basis points: 11 000 is ×1.1. */
+    multiplyBp: number;
+}
+export interface DiscountOption {
+    id: string;
+    labels: PricingLabels;
+    /** Taken off the subtotal, in basis points: 1 000 is 10 % off, 0 none. */
+    discountBp: number;
+}
+/**
+ * An enum the visitor answers — bedrooms, a surface band, a zone, a
+ * frequency. Its `kind` says what its options do, and when (see `priceOf`):
+ * every `add` first, then every `multiply`, then every `discount`.
+ */
+export type PricingInput = {
+    id: string;
+    kind: "add";
+    labels: PricingLabels;
+    options: readonly AddOption[];
+} | {
+    id: string;
+    kind: "multiply";
+    labels: PricingLabels;
+    options: readonly MultiplyOption[];
+} | {
+    id: string;
+    kind: "discount";
+    labels: PricingLabels;
+    options: readonly DiscountOption[];
+};
+export type PricingInputKind = PricingInput["kind"];
+/**
+ * How one need is priced. `estimate`: a base and the inputs the visitor
+ * answers, in the order the form asks them. `fixed`: one price, exactly —
+ * neither rounded nor raised to the minimum, which are the estimate's.
+ */
+export type NeedPricing = {
+    kind: "estimate";
+    baseCents: number;
+    inputs: readonly string[];
+} | {
+    kind: "fixed";
+    cents: number;
+};
+export interface PricingModel {
+    format: typeof PRICING_FORMAT;
+    currency: typeof PRICING_CURRENCY;
+    /** The date the prices hold from, `YYYY-MM-DD` — stored with every lead priced by it. */
+    validFrom: string;
+    /** The estimate's total is rounded half up to a multiple of this (1 = to the cent). */
+    roundToCents: number;
+    /** An estimate never comes out below this, after the rounding. */
+    minimumCents: number;
+    inputs: readonly PricingInput[];
+    /** By the brand's subject slug; a need not here is a `quote`. */
+    needs: Readonly<Record<string, NeedPricing>>;
+}
+/** The answers to an estimate's inputs: input id → option id. */
+export type PricingInputs = Readonly<Record<string, string>>;
+/**
+ * One line of how a price was reached; `cents` is what the line changed, so
+ * the lines add up to the total. `base` is the need's base (or the fixed
+ * price); `rounding` and `minimum` appear only when they changed something.
+ */
+export type PriceLine = {
+    kind: "base";
+    cents: number;
+} | {
+    kind: "add" | "multiply" | "discount";
+    input: string;
+    option: string;
+    cents: number;
+} | {
+    kind: "rounding";
+    cents: number;
+} | {
+    kind: "minimum";
+    cents: number;
+};
+export interface Price {
+    cents: number;
+    breakdown: readonly PriceLine[];
+}
+/**
+ * The model's limits. Ids are slugs (they travel to the panel as
+ * `estimate_inputs`, which takes at most 12 pairs); every amount, and every
+ * step of the dearest combination, stays at or under `MAX_PRICE_CENTS`, so
+ * each product fits a double exactly and a 64-bit integer with room to spare.
+ */
+export declare const PRICING_LIMITS: {
+    readonly slug: RegExp;
+    readonly locale: RegExp;
+    readonly maxLabel: 120;
+    readonly maxInputs: 32;
+    readonly maxOptions: 32;
+    readonly maxNeeds: 64;
+    /** Per need: what `estimate_inputs` may carry. */
+    readonly maxNeedInputs: 12;
+    readonly maxPriceCents: 100000000;
+    /** ×10 at most. */
+    readonly maxMultiplyBp: 100000;
+    readonly maxDiscountBp: 10000;
+};