@evinvest/kitstart 0.10.0 → 0.12.0

package/dist/core/booking/model.js

@@ -0,0 +1,66 @@
+/**
+ * Booking, provider-agnostic: how a place's slot is set once a priced lead is
+ * stored. The vocabulary is the panel's (snake_case, closed sets) and the
+ * fixtures in `test/fixtures/booking/` are the contract it mirrors: a new
+ * provider extends the closed set with its own URL rule, and nothing else on
+ * either side changes.
+ */
+/**
+ * - `manual`: no external page — the site promises a call to set the slot, and
+ *   the operator records it in the panel. Always available; carries no URL.
+ * - `link`: any external booking page (strict https), opened with
+ *   `ref=<leadRef>` in its query.
+ * - `google_calendar`: a Google appointment schedule, opened as is — it takes
+ *   no parameter, so the panel matches its bookings by contact and time.
+ * - `cal_com`: a Cal.com event, opened with the name, the phone and
+ *   `metadata[ref]=<leadRef>` prefilled.
+ */
+export const BOOKING_PROVIDERS = ["manual", "link", "google_calendar", "cal_com"];
+/** A place with no booking of its own — baked or live — promises a call. */
+export const DEFAULT_BOOKING = { default: "manual", providers: {} };
+/** The experiment whose variant names the provider a visitor is offered, the same key on every brand. */
+export const BOOKING_EXPERIMENT = "booking_provider";
+/** A lead's booking, as the panel's projection tracks it; the site only ever says `requested`. */
+export const BOOKING_STATUSES = ["none", "requested", "booked", "canceled", "done", "no_show"];
+/** The part of the day a visitor may prefer for a `manual` slot. */
+export const PREFERRED_PARTS = ["morning", "afternoon", "evening"];
+/** The Cal.com hosts a `cal_com` URL may point at unless the site names its own: ours, and the hosted cloud. */
+export const DEFAULT_CAL_COM_HOSTS = ["cal.evinvest.ltd", "cal.com"];
+export const BOOKING_LIMITS = {
+    maxUrl: 2048,
+    /** A Cal.com username or event slug: one path segment, no dot segment. */
+    calComSegment: /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/,
+};
+/** `lead-<row>-<8 hex>`, as `leadRef` mints it. */
+const LEAD_REF = /^lead-[1-9]\d{0,14}-[0-9a-f]{8}$/;
+export function isLeadRef(value) {
+    return typeof value === "string" && LEAD_REF.test(value);
+}
+export function isBookingProvider(value) {
+    return BOOKING_PROVIDERS.some(p => p === value);
+}
+export function isPageProvider(value) {
+    return value !== "manual" && isBookingProvider(value);
+}
+export function isPreferredPart(value) {
+    return PREFERRED_PARTS.some(p => p === value);
+}
+/**
+ * The one entry point for which booking a visitor is offered: the provider
+ * the experiment's variant (`booking_provider`) names, when the place has it
+ * (`manual` it always has), else the place's default. The chosen provider is
+ * what `booking.requested@1` and `lead_booking_open/done` report, so the arms
+ * compare.
+ */
+export function bookingOf(place, variant) {
+    const booking = place.booking ?? DEFAULT_BOOKING;
+    const pick = (provider) => {
+        if (provider === "manual")
+            return { provider };
+        if (!isPageProvider(provider))
+            return null;
+        const page = booking.providers[provider];
+        return page ? { provider, url: page.url } : null;
+    };
+    return pick(variant) ?? pick(booking.default) ?? { provider: "manual" };
+}

package/dist/core/booking/url.d.ts

@@ -0,0 +1,17 @@
+import type { BookingChoice } from "./model.js";
+/** What the page knows of the lead when the visitor asks for a slot. */
+export interface BookingPrefill {
+    leadRef: string;
+    /** As typed; `cal_com` only. */
+    name?: string | null | undefined;
+    /** As typed; `cal_com` only, and only as a number `normalizePhone` reads (E.164). */
+    phone?: string | null | undefined;
+}
+/**
+ * The page a click opens, or `null` for `manual`. The lead's reference goes
+ * in the QUERY, never the fragment: `link` as `ref=<leadRef>` (and nothing
+ * else — an arbitrary host gets no personal data); `cal_com` as
+ * `metadata[ref]` with the name and the phone. `google_calendar` takes no
+ * parameter: its URL as is, and the panel matches by contact and time.
+ */
+export declare function bookingHref(choice: BookingChoice, prefill: BookingPrefill): string | null;

package/dist/core/booking/url.js

@@ -0,0 +1,53 @@
+import { normalizePhone } from "../phone.js";
+function keyOf(pair) {
+    const key = pair.split("=", 1)[0] ?? "";
+    try {
+        return decodeURIComponent(key.replaceAll("+", " "));
+    }
+    catch {
+        return key;
+    }
+}
+/**
+ * `url` with `pairs` in its query, each replacing any pair of the same key
+ * the URL already had; the rest of the query is kept byte for byte. Keys go
+ * as written (`metadata[ref]`, as Cal.com documents it), values encoded.
+ */
+function withQuery(url, pairs) {
+    const u = new URL(url);
+    const keys = new Set(pairs.map(([k]) => k));
+    const kept = u.search
+        .slice(1)
+        .split("&")
+        .filter(p => p !== "" && !keys.has(keyOf(p)));
+    u.search = [...kept, ...pairs.map(([k, v]) => `${k}=${encodeURIComponent(v)}`)].join("&");
+    return u.toString();
+}
+/**
+ * The page a click opens, or `null` for `manual`. The lead's reference goes
+ * in the QUERY, never the fragment: `link` as `ref=<leadRef>` (and nothing
+ * else — an arbitrary host gets no personal data); `cal_com` as
+ * `metadata[ref]` with the name and the phone. `google_calendar` takes no
+ * parameter: its URL as is, and the panel matches by contact and time.
+ */
+export function bookingHref(choice, prefill) {
+    const name = prefill.name?.trim();
+    const phone = prefill.phone ? normalizePhone(prefill.phone) : null;
+    switch (choice.provider) {
+        case "manual":
+            return null;
+        case "link":
+            return withQuery(choice.url, [["ref", prefill.leadRef]]);
+        case "google_calendar":
+            return choice.url;
+        case "cal_com": {
+            const pairs = [];
+            if (name)
+                pairs.push(["name", name]);
+            if (phone)
+                pairs.push(["attendeePhoneNumber", phone]);
+            pairs.push(["metadata[ref]", prefill.leadRef]);
+            return withQuery(choice.url, pairs);
+        }
+    }
+}

package/dist/core/booking/validate.d.ts

@@ -0,0 +1,27 @@
+import { type BookingConfig, type BookingRequest, type BookingRequestedProperties, type BookingRules } from "./model.js";
+/** A booking config that does not validate, with every reason found. */
+export declare class BookingConfigError extends Error {
+    readonly problems: readonly string[];
+    readonly name = "BookingConfigError";
+    constructor(problems: readonly string[]);
+}
+/**
+ * Every reason `value` is not a place's booking, or none. Unknown fields are
+ * refused, not ignored — `manual` has no page entry — so the site and the
+ * panel never disagree on what a config says.
+ */
+export declare function bookingConfigProblems(value: unknown, rules?: BookingRules): string[];
+/** The config `value` is, rebuilt from what was checked; throws `BookingConfigError` with every problem. */
+export declare function parseBookingConfig(value: unknown, rules?: BookingRules): BookingConfig;
+/** Every reason a host list is not one a site may allow Cal.com on. */
+export declare function calComHostsProblems(hosts: readonly string[]): string[];
+/**
+ * Every reason `value` is not `booking.requested@1`'s properties, or none:
+ * a `lead_ref`, a provider of the closed set and, with `manual` only, an
+ * optional day and part of the day. No free text — nothing a person typed.
+ */
+export declare function bookingRequestProblems(value: unknown): string[];
+/** The request `value` is; throws `BookingConfigError` with every problem. */
+export declare function parseBookingRequest(value: unknown): BookingRequest;
+/** A request as `booking.requested@1`'s properties: snake_case, absent fields left out. */
+export declare function bookingRequestedProperties(request: BookingRequest): BookingRequestedProperties;

package/dist/core/booking/validate.js

@@ -0,0 +1,219 @@
+import { BOOKING_LIMITS as LIMIT, DEFAULT_CAL_COM_HOSTS, isBookingProvider, isLeadRef, isPageProvider, isPreferredPart, } from "./model.js";
+/** A booking config that does not validate, with every reason found. */
+export class BookingConfigError extends Error {
+    problems;
+    name = "BookingConfigError";
+    constructor(problems) {
+        super(`booking: ${problems.join("; ")}`);
+        this.problems = problems;
+    }
+}
+const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function unknownKeys(path, v, allowed) {
+    return Object.keys(v)
+        .filter(key => !allowed.includes(key))
+        .map(key => `${path}.${key}: unknown field`);
+}
+// Printable ASCII only: the URL parser would quietly drop a tab or a line
+// break and re-encode the rest, so what was checked would not be what opens.
+const PRINTABLE_ASCII = /^[\x21-\x7e]+$/;
+const LABEL = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$/;
+// A last label that is a number (or `0x…`) makes the WHATWG parser read the
+// host as an IPv4 address: `https://0x7f000001/` is 127.0.0.1.
+const NUMERIC_LABEL = /^(?:\d+|0x[0-9a-f]*)$/i;
+/**
+ * Every reason `value` is not a booking URL. The rules are the panel's too
+ * (`test/fixtures/booking/README.md`): a literal lowercase `https://`, a
+ * dotted DNS name for a host — no userinfo, no port, no IP literal — no
+ * fragment, printable ASCII, at most 2048 characters.
+ */
+function urlProblems(path, value) {
+    const fail = (why) => ({ problems: [`${path}: ${why}`], url: null, rawPath: "" });
+    if (typeof value !== "string")
+        return fail("a URL string");
+    if (value.length > LIMIT.maxUrl)
+        return fail(`at most ${LIMIT.maxUrl} characters`);
+    if (!PRINTABLE_ASCII.test(value))
+        return fail("printable ASCII only, no spaces or control characters");
+    if (!value.startsWith("https://"))
+        return fail('must start with "https://"');
+    if (value.includes("#"))
+        return fail("no fragment");
+    if (value.includes("\\"))
+        return fail("no backslash");
+    const rest = value.slice("https://".length);
+    const end = rest.search(/[/?]/);
+    const authority = end === -1 ? rest : rest.slice(0, end);
+    if (authority.includes("@"))
+        return fail("no userinfo");
+    if (authority.includes(":") || authority.startsWith("["))
+        return fail("no port and no IP literal");
+    const labels = authority.split(".");
+    if (labels.length < 2 || authority.length > 253 || !labels.every(l => LABEL.test(l)))
+        return fail("the host must be a dotted DNS name");
+    if (NUMERIC_LABEL.test(labels[labels.length - 1] ?? ""))
+        return fail("the host must not be an IP literal");
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return fail("not a URL");
+    }
+    const query = rest.indexOf("?");
+    const rawPath = end === -1 ? "" : rest.slice(end, query === -1 ? undefined : query);
+    return { problems: [], url, rawPath };
+}
+function calComProblems(path, url, rawPath, rules) {
+    const hosts = rules.calComHosts ?? DEFAULT_CAL_COM_HOSTS;
+    const out = [];
+    if (!hosts.includes(url.hostname))
+        out.push(`${path}: the host must be one of ${hosts.join(", ")}`);
+    const segments = rawPath.split("/").slice(1);
+    if (!rawPath.startsWith("/") || segments.length !== 2 || !segments.every(s => LIMIT.calComSegment.test(s))) {
+        out.push(`${path}: the path must be /<user>/<event>`);
+    }
+    return out;
+}
+/** A non-empty path: a page on the host, not the host's home. */
+const hasPath = (rawPath) => rawPath !== "" && rawPath !== "/";
+const GOOGLE_SHORT = "calendar.app.google";
+const GOOGLE_LONG = "calendar.google.com";
+const GOOGLE_PATH = "/calendar/appointments/";
+/** The provider's own rule over the URL rule every provider shares. */
+function providerProblems(path, provider, url, rawPath, rules) {
+    switch (provider) {
+        case "link":
+            return [];
+        case "google_calendar":
+            if (url.hostname === GOOGLE_SHORT)
+                return hasPath(rawPath) ? [] : [`${path}: the path must name a schedule`];
+            if (url.hostname === GOOGLE_LONG)
+                return rawPath.startsWith(GOOGLE_PATH) && rawPath.length > GOOGLE_PATH.length ? [] : [`${path}: the path must be ${GOOGLE_PATH}…`];
+            return [`${path}: the host must be ${GOOGLE_SHORT} or ${GOOGLE_LONG}`];
+        case "cal_com":
+            return calComProblems(path, url, rawPath, rules);
+    }
+}
+function check(value, rules) {
+    if (!isObject(value))
+        return { problems: ["booking: an object"], config: null };
+    const problems = unknownKeys("booking", value, ["default", "providers"]);
+    const providers = {};
+    if (!isObject(value.providers))
+        problems.push("booking.providers: an object by provider");
+    else {
+        for (const [name, page] of Object.entries(value.providers)) {
+            const path = `booking.providers.${name}`;
+            if (name === "manual") {
+                problems.push(`${path}: manual has no page — it is always available`);
+                continue;
+            }
+            if (!isPageProvider(name)) {
+                problems.push(`${path}: not a provider (link, google_calendar, cal_com)`);
+                continue;
+            }
+            if (!isObject(page)) {
+                problems.push(`${path}: an object, { url }`);
+                continue;
+            }
+            problems.push(...unknownKeys(path, page, ["url"]));
+            if (!Object.hasOwn(page, "url")) {
+                problems.push(`${path}.url: missing`);
+                continue;
+            }
+            const parsed = urlProblems(`${path}.url`, page.url);
+            problems.push(...parsed.problems);
+            if (parsed.url)
+                problems.push(...providerProblems(`${path}.url`, name, parsed.url, parsed.rawPath, rules));
+            if (typeof page.url === "string")
+                providers[name] = { url: page.url };
+        }
+    }
+    const fallback = value.default;
+    if (!isBookingProvider(fallback))
+        problems.push("booking.default: one of manual, link, google_calendar, cal_com");
+    else if (fallback !== "manual" && !Object.hasOwn(providers, fallback))
+        problems.push(`booking.default: "${fallback}" is not one of the providers`);
+    if (problems.length > 0 || !isBookingProvider(fallback))
+        return { problems, config: null };
+    return { problems: [], config: { default: fallback, providers } };
+}
+/**
+ * Every reason `value` is not a place's booking, or none. Unknown fields are
+ * refused, not ignored — `manual` has no page entry — so the site and the
+ * panel never disagree on what a config says.
+ */
+export function bookingConfigProblems(value, rules = {}) {
+    return check(value, rules).problems;
+}
+/** The config `value` is, rebuilt from what was checked; throws `BookingConfigError` with every problem. */
+export function parseBookingConfig(value, rules = {}) {
+    const { problems, config } = check(value, rules);
+    if (!config)
+        throw new BookingConfigError(problems);
+    return config;
+}
+/** Every reason a host list is not one a site may allow Cal.com on. */
+export function calComHostsProblems(hosts) {
+    return hosts.flatMap((host, i) => {
+        const labels = host.split(".");
+        const dns = host === host.toLowerCase() && labels.length >= 2 && labels.every(l => LABEL.test(l)) && !NUMERIC_LABEL.test(labels[labels.length - 1] ?? "");
+        return dns ? [] : [`calComHosts[${i}]: a lowercase dotted DNS name, not ${JSON.stringify(host)}`];
+    });
+}
+/** `YYYY-MM-DD`, and a day the calendar has. */
+function isDay(v) {
+    if (typeof v !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(v))
+        return false;
+    const day = new Date(`${v}T00:00:00Z`);
+    return !Number.isNaN(day.getTime()) && day.toISOString().slice(0, 10) === v;
+}
+function checkRequest(value) {
+    if (!isObject(value))
+        return { problems: ["booking.requested: an object"], request: null };
+    const problems = unknownKeys("booking.requested", value, ["lead_ref", "provider", "preferred_date", "preferred_part"]);
+    const { lead_ref: leadRef, provider, preferred_date: date, preferred_part: part } = value;
+    if (!isLeadRef(leadRef))
+        problems.push("booking.requested.lead_ref: lead-<row>-<8 hex>");
+    if (!isBookingProvider(provider))
+        problems.push("booking.requested.provider: one of manual, link, google_calendar, cal_com");
+    if (date !== undefined && !isDay(date))
+        problems.push("booking.requested.preferred_date: a date, YYYY-MM-DD");
+    if (part !== undefined && !isPreferredPart(part))
+        problems.push("booking.requested.preferred_part: morning, afternoon or evening");
+    if ((date !== undefined || part !== undefined) && provider !== "manual")
+        problems.push("booking.requested: a preference only with manual");
+    if (problems.length > 0 || !isLeadRef(leadRef) || !isBookingProvider(provider))
+        return { problems, request: null };
+    const request = { leadRef, provider };
+    if (typeof date === "string")
+        request.preferredDate = date;
+    if (isPreferredPart(part))
+        request.preferredPart = part;
+    return { problems: [], request };
+}
+/**
+ * Every reason `value` is not `booking.requested@1`'s properties, or none:
+ * a `lead_ref`, a provider of the closed set and, with `manual` only, an
+ * optional day and part of the day. No free text — nothing a person typed.
+ */
+export function bookingRequestProblems(value) {
+    return checkRequest(value).problems;
+}
+/** The request `value` is; throws `BookingConfigError` with every problem. */
+export function parseBookingRequest(value) {
+    const { problems, request } = checkRequest(value);
+    if (!request)
+        throw new BookingConfigError(problems);
+    return request;
+}
+/** A request as `booking.requested@1`'s properties: snake_case, absent fields left out. */
+export function bookingRequestedProperties(request) {
+    return {
+        lead_ref: request.leadRef,
+        provider: request.provider,
+        ...(request.preferredDate !== undefined ? { preferred_date: request.preferredDate } : {}),
+        ...(request.preferredPart !== undefined ? { preferred_part: request.preferredPart } : {}),
+    };
+}

package/dist/core/lead-capture-text.d.ts

@@ -41,7 +41,7 @@ export interface LeadCaptureText extends Partial<LeadCaptureFlowText> {
     formInvalid: string;
     /** On the submit while the script posts the form. */
     sending: string;
-    /** The post never reached the server: nothing was sent, the form is as typed. */
+    /** The post got no answer — the lead may be stored already: a retry cannot make a second one. */
     networkError: string;
     /** No answer in time: it may have arrived — a retry cannot make a second lead. */
     timeoutError: string;
@@ -98,8 +98,32 @@ export interface LeadCaptureFlowText {
     bookSubmit: string;
     /** The in-card success of a priced lead; `{price}` the server's. */
     sentPrice: string;
-    /** After a priced lead: the slot is set by a call (no booking provider yet). */
+    /** After a priced lead with a `manual` booking: the slot is set by a call. */
     slotCallback: string;
+    /** The price changed under the form: `{price}` the fresh one, `{shown}` the one shown; the submit confirms it. */
+    priceChanged: string;
+    /** The same, without a script — the page shows the fresh price for the answers given again. */
+    priceChangedGeneric: string;
+    /** Opens the place's booking page (`link`, `cal_com`). */
+    bookCta: string;
+    /** Under it, for a provider the number cannot be handed to (Google): type the same one there. */
+    bookPhoneHint: string;
+    /** Under it: the call still comes if the visitor books nothing. */
+    bookNote: string;
+    /** Once the provider says the slot is booked. */
+    booked: string;
+    /** `manual`: the optional preference, its day and part of the day. */
+    preferTitle: string;
+    preferDay: string;
+    preferPart: string;
+    partMorning: string;
+    partAfternoon: string;
+    partEvening: string;
+    preferSubmit: string;
+    /** After the preference is sent. */
+    preferSent: string;
+    /** The preference did not reach the site; the call is still coming. */
+    preferFailed: string;
     /** A `quote` need that is priced from photos: the ask, and its WhatsApp link. */
     photosTitle: string;
     photosLede: string;

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

@@ -8,6 +8,21 @@ const FR_FLOW = {
     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",
@@ -23,6 +38,21 @@ const EN_FLOW = {
     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",
@@ -45,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",
@@ -84,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",

package/dist/core/lead.d.ts

@@ -109,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.

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.

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)