@evinvest/kitstart 0.17.0 → 0.19.1

package/dist/react/messenger/thanks.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "@evinvest/uikit";
+import { hrefOf, InappHint, MessengerCta, QrPanel, useDesktop, useMessage, useMessengerAction, wordsOf } from "./action.js";
+/**
+ * AQ-3: the form is the control's; its success adds the faster way — a photo
+ * on WhatsApp, the message carrying the lead's own reference — and the bot.
+ * On a computer, WhatsApp is a QR code to scan with the phone that takes the
+ * photo. The lead is sent already: a tap here posts nothing.
+ */
+export default function Thanks({ kit }) {
+    const words = wordsOf(kit);
+    const message = useMessage(kit);
+    const action = useMessengerAction(kit, message, () => undefined, { followUp: true });
+    const desktop = useDesktop();
+    const whatsapp = hrefOf(kit, "whatsapp", message.message);
+    return (_jsxs("div", { className: cn("flex flex-col gap-3 border-t border-border pt-4", kit.classNames?.messenger), children: [whatsapp && !desktop && _jsx("p", { className: "font-medium text-ink", children: words.messengerThanksTitle }), whatsapp && (desktop ? _jsx(QrPanel, { href: whatsapp, words: words, onCallback: null, kit: kit }) : _jsx(MessengerCta, { kit: kit, action: action, channel: "whatsapp", label: words.messengerThanksCta })), whatsapp && !desktop && _jsx(InappHint, { kit: kit, message: message.message }), kit.facts.telegram && _jsx(MessengerCta, { kit: kit, action: action, channel: "telegram", label: desktop ? words.messengerTelegramCta : words.messengerOptionTelegram, variant: "outline" })] }));
+}

package/dist/react/messenger/tiles.d.ts

@@ -0,0 +1,8 @@
+import type { MessengerKit } from "./types.js";
+/**
+ * VF-2: «Recevoir mon devis par» and a tile per channel — WhatsApp, Telegram,
+ * Appel — over a slot of one height: the message, what the bot does, or the phone.
+ */
+export default function Tiles({ kit }: {
+    kit: MessengerKit;
+}): import("react").JSX.Element;

package/dist/react/messenger/tiles.js

@@ -0,0 +1,20 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn, ToggleGroup, ToggleGroupItem } from "@evinvest/uikit";
+import { Glyph, labelOf, ModeBody, modesOf, toCall, useMessage, useMessengerAction, wordsOf } from "./action.js";
+/**
+ * VF-2: «Recevoir mon devis par» and a tile per channel — WhatsApp, Telegram,
+ * Appel — over a slot of one height: the message, what the bot does, or the phone.
+ */
+export default function Tiles({ kit }) {
+    const words = wordsOf(kit);
+    const message = useMessage(kit);
+    const action = useMessengerAction(kit, message, () => toCall(kit));
+    const modes = modesOf(kit, ["whatsapp", "telegram", "call"]);
+    const mode = kit.mode ?? "whatsapp";
+    return (_jsxs("div", { className: cn("flex flex-col gap-3", kit.classNames?.messenger), children: [_jsx("p", { className: "text-sm font-medium text-ink", children: words.messengerTilesLabel }), _jsx(ToggleGroup, { role: "group", type: "single", value: mode, onValueChange: v => {
+                    const picked = modes.find((m) => m === v);
+                    if (picked)
+                        kit.setMode(picked);
+                }, "aria-label": words.messengerTilesLabel, className: cn("grid w-full gap-2", modes.length === 3 ? "grid-cols-3" : "grid-cols-2", kit.classNames?.messengerPicker), children: modes.map(m => (_jsxs(ToggleGroupItem, { value: m, className: cn("h-11 gap-2 rounded-[var(--control-radius)] border border-border first:rounded-[var(--control-radius)] last:rounded-[var(--control-radius)] data-[state=on]:border-primary data-[state=on]:text-ink", kit.classNames?.messengerOption, kit.classNames?.messengerTile), children: [_jsx(Glyph, { kit: kit, channel: m }), labelOf(words, m)] }, m))) }), _jsx(ModeBody, { kit: kit, message: message, action: action }), action.overlay] }));
+}

package/dist/react/messenger/types.d.ts

@@ -0,0 +1,98 @@
+import type { ReactNode } from "react";
+import type { LeadWire } from "../../core/lead.js";
+import type { LeadCaptureText } from "../../core/lead-capture-text.js";
+import type { MessengerFacts, MessengerMode, MessengerVariant } from "../../core/messenger.js";
+import type { ChannelIconKey, Experiment } from "../LeadCaptureChannels.js";
+import type { LeadNeedOption } from "../LeadCaptureNeed.js";
+import type { PartClassNames } from "../parts.js";
+import type { LeadEvents } from "../use-lead-events.js";
+/**
+ * Where in the card a variant draws: in place of the heading (`head`), under
+ * it (`afterHead`), before the need (`beforeNeed`), in place of the form's
+ * fields (`body`), in place of the phone and the submit (`contact`), under
+ * the submit (`afterSubmit`), or in the success (`done`).
+ */
+export type MessengerAt = "head" | "afterHead" | "beforeNeed" | "body" | "contact" | "afterSubmit" | "done";
+/** A variant as drawn: its own kind, or the control with a way to the bot (`fallback`). */
+export type MessengerShown = MessengerVariant["kind"] | "fallback";
+/**
+ * The parts a variant dresses; a brand sizes `messengerSlot` (92 px, 72 px)
+ * so no state of a variant moves the card. `messengerCta`: a variant's main
+ * button — a messenger's, or the call's submit; `messengerSecondary`: the
+ * others (Telegram and «Être rappelé» beside it, «ou via Telegram», the way
+ * back to the chat); `messengerSquare`: the icon squares; `messengerSegment`,
+ * `messengerTile`: a segment's and a tile's item, after `messengerOption`;
+ * `messengerTrigger`: the channel picker's button (`select`, `chip`).
+ */
+export type MessengerPart = "messenger" | "messengerSlot" | "messengerCta" | "messengerSecondary" | "messengerSegment" | "messengerTile" | "messengerTrigger" | "messengerPreview" | "messengerPicker" | "messengerOption" | "messengerSquare" | "messengerQr" | "messengerReturn" | "messengerHint";
+/** How a variant asks for the card's phone field. */
+export interface PhoneOptions {
+    optional?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    /** The variant's box around the input (`PhoneField`'s `frame`). */
+    frame?: (input: ReactNode) => ReactNode;
+    /** The form's id, for a field drawn outside the form's element (a drawer). */
+    form?: string;
+    /** Under the field instead of the brand's `afterPhone`. */
+    after?: ReactNode;
+}
+/**
+ * What `LeadCapture` hands a variant: the card's facts and state, and its own
+ * pieces — the phone field and the submit — so a variant arranges them and
+ * never re-implements them.
+ */
+export interface MessengerKit {
+    at: MessengerAt;
+    variant: MessengerVariant;
+    shown: MessengerShown;
+    facts: MessengerFacts;
+    /** The card's id; its form is `<id>-form`. */
+    id: string;
+    locale: string;
+    /** The brand's name, the message's greeting. */
+    brand: string;
+    text: LeadCaptureText;
+    wire: LeadWire;
+    needs: readonly LeadNeedOption[];
+    /** The need on screen, by its label — for the message. */
+    needLabel: string | null;
+    /** The estimate the card shows, formatted — for the message. */
+    priceText: string | null;
+    /** The estimate's answers, by their short labels, in order — the timing question's left out. */
+    answers: readonly string[];
+    /**
+     * The answer to the estimate's question the brand names (`messengerTiming`):
+     * its label for the message's timing line, its short one for the preview.
+     */
+    timing: {
+        label: string;
+        short: string;
+    } | null;
+    /** The channel the visitor is on; `null` before a variant asks (`saga`, `urgency`). */
+    mode: MessengerMode | null;
+    setMode: (mode: MessengerMode | null) => void;
+    /** The card's reference (`message_ref`), minted once the script runs; `null` before. */
+    messageRef: string | null;
+    /**
+     * Whether a messenger link may lead anywhere: the script runs and the
+     * reference is minted. Until then a tap would open the chat with no lead
+     * posted and no `Réf.` to find it by — the links are inert.
+     */
+    ready: boolean;
+    /** A new reference, once a messenger lead is posted. */
+    renewRef: () => void;
+    phone: (options?: PhoneOptions) => ReactNode;
+    /** The card's submit — a call lead, posted as the control posts it. */
+    submit: (label?: string, options?: {
+        form?: string;
+        className?: string;
+    }) => ReactNode;
+    /** The default heading's words, for a variant that redraws the heading. */
+    title: string;
+    lede: string;
+    events: LeadEvents;
+    icons: Partial<Record<ChannelIconKey, ReactNode>> | undefined;
+    experiment: Experiment | undefined;
+    classNames: PartClassNames<MessengerPart> | undefined;
+}

package/dist/react/messenger/types.js

@@ -0,0 +1 @@
+export {};

package/dist/react/messenger/urgency.d.ts

@@ -0,0 +1,10 @@
+import type { MessengerKit } from "./types.js";
+/**
+ * AQ-6: «C’est urgent ?» picks the channel — today is a call, «je compare»
+ * the message ready in the slot — and the answer is the lead's, posted as
+ * the brand's extra (`field`, which `site.lead.extras` must list). Without
+ * WhatsApp the question stays, and both answers ask the phone.
+ */
+export default function Urgency({ kit }: {
+    kit: MessengerKit;
+}): import("react").JSX.Element;

package/dist/react/messenger/urgency.js

@@ -0,0 +1,29 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn, ToggleGroup, ToggleGroupItem } from "@evinvest/uikit";
+import { fillText } from "../../core/lead-capture-format.js";
+import { MessengerCta, InappHint, Preview, Slot, TelegramLink, toCall, useMessage, useMessengerAction, wordsOf } from "./action.js";
+/** What the answer is posted as, in the brand's extra: a slug, never the label. */
+const ANSWER = { call: "today", whatsapp: "later" };
+/**
+ * AQ-6: «C’est urgent ?» picks the channel — today is a call, «je compare»
+ * the message ready in the slot — and the answer is the lead's, posted as
+ * the brand's extra (`field`, which `site.lead.extras` must list). Without
+ * WhatsApp the question stays, and both answers ask the phone.
+ */
+export default function Urgency({ kit }) {
+    return kit.at === "beforeNeed" ? _jsx(Question, { kit: kit }) : _jsx(UrgencyContact, { kit: kit });
+}
+function Question({ kit }) {
+    const words = wordsOf(kit);
+    const field = kit.variant.kind === "urgency" ? kit.variant.field : "urgency";
+    const answer = kit.mode === "call" || kit.mode === "whatsapp" ? kit.mode : null;
+    return (_jsxs("div", { className: cn("flex flex-col gap-2", kit.classNames?.messenger), children: [_jsx("p", { className: "text-sm font-medium text-ink", children: words.messengerUrgencyLabel }), _jsx(ToggleGroup, { role: "group", type: "single", value: answer ?? "", onValueChange: v => (v === "call" || v === "whatsapp" ? kit.setMode(v) : undefined), "aria-label": words.messengerUrgencyLabel, className: cn("grid w-full grid-cols-2 gap-2", kit.classNames?.messengerPicker), children: ["call", "whatsapp"].map(m => (_jsx(ToggleGroupItem, { value: m, className: cn("h-11 rounded-[var(--control-radius)] border border-border first:rounded-[var(--control-radius)] last:rounded-[var(--control-radius)] data-[state=on]:border-primary data-[state=on]:text-ink", kit.classNames?.messengerOption, kit.classNames?.messengerTile), children: m === "call" ? words.messengerUrgencyYes : words.messengerUrgencyNo }, m))) }), answer && _jsx("input", { type: "hidden", name: field, value: ANSWER[answer] })] }));
+}
+function UrgencyContact({ kit }) {
+    const words = wordsOf(kit);
+    const message = useMessage(kit, kit.mode === "call" ? words.messengerUrgencyToday : kit.mode === "whatsapp" ? words.messengerUrgencyLater : null);
+    const action = useMessengerAction(kit, message, () => toCall(kit));
+    const chat = kit.mode === "whatsapp" && kit.facts.whatsapp !== null;
+    return (_jsxs("div", { className: cn("flex flex-col gap-3", kit.classNames?.messenger), children: [_jsx(Slot, { kit: kit, children: chat ? (action.panel ?? _jsx(Preview, { kit: kit, preview: message.preview, title: words.messengerNotUrgentTitle, lede: fillText(words.messengerNotUrgentLede, { ref: kit.messageRef ?? "" }) })) : kit.phone() }), chat ? _jsx(MessengerCta, { kit: kit, action: action, channel: "whatsapp", label: words.messengerWhatsappCta }) : kit.submit(kit.mode === "call" ? words.messengerUrgentSubmit : undefined), chat && _jsx(InappHint, { kit: kit, message: message.message }), _jsx(TelegramLink, { kit: kit, action: action }), action.overlay] }));
+}

package/dist/react/use-lead-error.d.ts

@@ -1,11 +1,11 @@
 import { type RefObject } from "react";
-import { type LeadChannel, type LeadError } from "../core/lead.js";
+import { type LeadError } from "../core/lead.js";
 import type { LeadCaptureText } from "../core/lead-capture-text.js";
 export type { LeadError };
 /** The fields `LeadCapture` draws itself, which show a refusal under themselves. */
-export declare const OWN_FIELDS: Readonly<Record<LeadChannel, readonly string[]>>;
+export declare const OWN_FIELDS: Readonly<Record<LeadError["channel"], readonly string[]>>;
 /** The id of the message a refusal of a field the card does not draw is shown in, above the submit. */
-export declare const formMessageId: (id: string, channel: LeadChannel) => string;
+export declare const formMessageId: (id: string, channel: LeadError["channel"]) => string;
 /** The words for a refused field: the field's own rule where the form has one. */
 export declare function errorText(field: string, text: LeadCaptureText): string;
 /**

package/dist/react/use-lead-events.d.ts

@@ -1,5 +1,6 @@
 import { type RefObject } from "react";
 import { type LeadField, type LeadStep } from "../core/analytics.js";
+import type { ChannelsAvailable } from "../core/messenger.js";
 /** The attribute a lead form's control names its role in, for `lead_form_field_error`. */
 export declare const FIELD_ATTR = "data-lead-field";
 export interface LeadEvents {
@@ -10,13 +11,30 @@ export interface LeadEvents {
     submitError(reason: "network" | "timeout", channel: "form" | "callback"): void;
     /** An estimate's price for a full set of answers: its band only, once per need and band. */
     estimateShown(need: string, cents: number): void;
+    /** A messenger CTA: the lead posted, the visitor sent on — never what was typed. */
+    messengerOpen(open: {
+        channel: "whatsapp" | "telegram";
+        device: "mobile" | "desktop";
+        inapp: boolean;
+        ref: string | null;
+    }): void;
+    /** On a computer: the QR code that opens WhatsApp on the phone was shown (`contact_intent_click`, `whatsapp_qr`). */
+    qrShown(): void;
+    /** Back on the page after a messenger: what the visitor said of it. */
+    messengerReturn(back: {
+        channel: "whatsapp" | "telegram";
+        answer: "sent" | "failed";
+        ref: string | null;
+    }): void;
 }
 /**
  * The lead form's own funnel, reported through the boundary's sink: seen
  * (half of it in view, once), started (the first focus inside, once), a
  * field the browser refused (`invalid`, by role — never the value), and the
  * step `qualify-first` moved to. Every event carries the form, the layout and
- * the site's experiment, so the arms of a test compare on one schema.
+ * the site's experiment, so the arms of a test compare on one schema — and
+ * the messengers the card offered (`channels_available`) and its `messenger`
+ * variant, so an arm that fell back to the control is told apart.
  */
 export declare function useLeadEvents(root: RefObject<HTMLElement | null>, tags: {
     formId: string;
@@ -25,4 +43,6 @@ export declare function useLeadEvents(root: RefObject<HTMLElement | null>, tags:
         name: string;
         variant: string;
     } | undefined;
+    channels?: ChannelsAvailable | undefined;
+    messenger?: string | undefined;
 }): LeadEvents;

package/dist/react/use-lead-events.js

@@ -10,14 +10,16 @@ export const FIELD_ATTR = "data-lead-field";
  * (half of it in view, once), started (the first focus inside, once), a
  * field the browser refused (`invalid`, by role — never the value), and the
  * step `qualify-first` moved to. Every event carries the form, the layout and
- * the site's experiment, so the arms of a test compare on one schema.
+ * the site's experiment, so the arms of a test compare on one schema — and
+ * the messengers the card offered (`channels_available`) and its `messenger`
+ * variant, so an arm that fell back to the control is told apart.
  */
 export function useLeadEvents(root, tags) {
     const sink = useAnalyticsSink();
-    const { formId, layout } = tags;
+    const { formId, layout, channels, messenger } = tags;
     const name = tags.experiment?.name;
     const variant = tags.experiment?.variant;
-    const props = useMemo(() => ({ form_id: formId, layout, ...experimentProps(name, variant) }), [formId, layout, name, variant]);
+    const props = useMemo(() => ({ form_id: formId, layout, ...experimentProps(name, variant), ...(channels ? { channels_available: channels } : {}), ...(messenger ? { messenger_variant: messenger } : {}) }), [formId, layout, name, variant, channels, messenger]);
     const started = useRef(false);
     const shown = useRef(new Set());
     useEffect(() => {
@@ -69,5 +71,9 @@ export function useLeadEvents(root, tags) {
             shown.current.add(key);
             sink?.capture(EVENTS.estimateShown, { ...props, need, cents_bucket });
         },
+        // Beacons: the page is being left for the app.
+        messengerOpen: ({ channel, device, inapp, ref }) => sink?.capture(EVENTS.messengerOpen, { ...props, channel, device, inapp, ...(ref ? { message_ref: ref } : {}) }, { transport: "beacon" }),
+        qrShown: () => sink?.capture(EVENTS.intent, { ...props, channel: "whatsapp_qr" }),
+        messengerReturn: ({ channel, answer, ref }) => sink?.capture(EVENTS.messengerReturn, { ...props, channel, answer, ...(ref ? { message_ref: ref } : {}) }),
     }), [sink, props]);
 }

package/dist/react/use-lead-submit.d.ts

@@ -1,8 +1,13 @@
 import { type FormEventHandler } from "react";
 import { type LeadChannel } from "../core/lead.js";
+/**
+ * Which of the card's forms a submit posts: a messenger lead is posted in the
+ * background instead (`postInBackground`), and never answers in the card.
+ */
+export type FormChannel = Extract<LeadChannel, "form" | "callback">;
 /** What the visitor just sent, for a brand's in-card success ("we call 06 … back"). */
 export interface LeadSent {
-    channel: LeadChannel;
+    channel: FormChannel;
     /** As typed. */
     phone: string;
     /** The name field's value, when the form has one and it was filled. */
@@ -26,6 +31,15 @@ export declare const navigation: {
  * over plain http is not one, but `getRandomValues` works everywhere.
  */
 export declare function newSubmissionId(): string;
+/**
+ * A messenger lead: the form as it stands, with `extra` over it (the
+ * channel, the reference), posted as the visitor leaves for the chat —
+ * `keepalive`, so the request outlives the page handing over to the app. No
+ * answer is waited for and none is shown: the chat is where it goes on. A
+ * second tap on the same lead carries the same submission id, so the route
+ * stores it once. Resolves whether the route took it.
+ */
+export declare function postInBackground(form: HTMLFormElement, extra: Readonly<Record<string, string>>, analyticsId: string | null): Promise<boolean>;
 /** Why the script's post got no answer: none came back (`network`), or none in time (`timeout`). */
 export type SendFailure = "network" | "timeout";
 /** How long the script waits for `/quote` before it says so; the lead is a few short fields. */
@@ -33,18 +47,18 @@ export declare const SUBMIT_TIMEOUT_MS = 15000;
 export interface LeadSubmitHandlers {
     /** The route refused the lead: the field to fix. */
     /** `cents`: with `price_changed`, the server's fresh price. */
-    onRefused: (channel: LeadChannel, field: string, cents?: number) => void;
+    onRefused: (channel: FormChannel, field: string, cents?: number) => void;
     /** No answer: the form stays as typed, with a retry. */
-    onFailed: (channel: LeadChannel, failure: SendFailure) => void;
+    onFailed: (channel: FormChannel, failure: SendFailure) => void;
 }
 export interface LeadSubmit {
     sent: LeadSent | null;
     onSubmit: FormEventHandler<HTMLFormElement>;
     /** The form being posted, while it is. */
-    busy: LeadChannel | null;
+    busy: FormChannel | null;
     /** The last post that got no answer, until the next one. */
     failure: {
-        channel: LeadChannel;
+        channel: FormChannel;
         failure: SendFailure;
     } | null;
     /** Posts that form again — the same submission id, so never a second lead. */
@@ -60,7 +74,7 @@ export interface LeadSubmit {
  * form. Any other answer (the store's 500) submits the form for real, so the
  * server's own page says what went wrong; the submission id makes that safe.
  */
-export declare function useLeadSubmit(done: boolean | ((channel: LeadChannel) => boolean), fields: {
+export declare function useLeadSubmit(done: boolean | ((channel: FormChannel) => boolean), fields: {
     mobile: string;
     name: string | undefined;
 }, on: LeadSubmitHandlers): LeadSubmit;

package/dist/react/use-lead-submit.js

@@ -31,18 +31,40 @@ const minted = new WeakMap();
  * fixed after a timeout is another lead, which must not be answered with the
  * first one's row.
  */
-function stamp(form) {
+function stamp(form, extra = {}) {
     const field = form.elements.namedItem(SUBMISSION_FIELD);
     if (!(field instanceof HTMLInputElement))
         return;
     const posted = new FormData(form);
     posted.delete(SUBMISSION_FIELD);
+    for (const [key, value] of Object.entries(extra))
+        posted.set(key, value);
     const lead = new URLSearchParams([...posted].filter((e) => typeof e[1] === "string")).toString();
     const known = minted.get(form);
     const id = known && known.lead === lead ? known.id : newSubmissionId();
     minted.set(form, { id, lead });
     field.value = id;
 }
+/**
+ * A messenger lead: the form as it stands, with `extra` over it (the
+ * channel, the reference), posted as the visitor leaves for the chat —
+ * `keepalive`, so the request outlives the page handing over to the app. No
+ * answer is waited for and none is shown: the chat is where it goes on. A
+ * second tap on the same lead carries the same submission id, so the route
+ * stores it once. Resolves whether the route took it.
+ */
+export function postInBackground(form, extra, analyticsId) {
+    stamp(form, extra);
+    const body = new URLSearchParams();
+    for (const [key, value] of new FormData(form))
+        if (typeof value === "string" && !(key in extra))
+            body.append(key, value);
+    for (const [key, value] of Object.entries(extra))
+        body.set(key, value);
+    if (analyticsId)
+        body.set(ANALYTICS_ID_FIELD, analyticsId);
+    return fetch(form.action, { method: "POST", body, headers: { Accept: "application/json" }, keepalive: true }).then(res => res.ok, () => false);
+}
 const LEAD_REF = /^lead-\d+-[0-9a-f]{8}$/;
 /** A root-relative path on this origin — never `//elsewhere`. */
 const OWN_PATH = /^\/(?!\/)/;

package/dist/server/index.d.ts

@@ -16,6 +16,6 @@ export { parseSmtpUrl, sendMail, type Mail, type SendOptions } from "./smtp.js";
 export { defaultLeadMail, leadNotifier, MAIL_PER_MINUTE, type LeadMail, type LeadMailShown, type LeadNotifier, type NeedLabel, type NotifyEnv } from "./notify.js";
 export { clientKey, NO_CLIENT_ADDRESS, parseProxyTrust, type ProxyTrust } from "./client-key.js";
 export { checkLeadStore } from "./boot.js";
-export { leadWebhook, panelChannel, panelFlowOf, panelFlowProperties, type BookingQueued, type BookingWebhookContext, type BuildBookingBody, type BuildWebhookBody, type LeadWebhook, type LeadWebhookContext, type LeadWebhookOptions, type PanelFlow, type PanelFlowProperties, } from "./lead-webhook.js";
+export { leadWebhook, panelChannel, panelFlowOf, panelFlowProperties, type BookingQueued, type BookingWebhookContext, type BuildBookingBody, type BuildWebhookBody, type LeadWebhook, type LeadWebhookContext, type LeadWebhookOptions, type PanelChannel, type PanelFlow, type PanelFlowProperties, } from "./lead-webhook.js";
 export { checkWebhookUrl, openWebhookOutbox, WEBHOOK_HORIZON_MS, WEBHOOK_MAX_ATTEMPTS, WEBHOOK_MAX_DELAY_MS, WEBHOOK_TICK_MS, type DeadRow, type OutboxRow, type OutboxState, type TickReport, type WebhookOutbox, type WebhookOutboxOptions, type WebhookTarget, } from "./webhook-outbox.js";
 export { signatureHeaders, signWebhook, type WebhookSignatureHeaders, type WebhookSigning } from "./webhook-signature.js";

package/dist/server/lead-store-sqlite.js

@@ -1,7 +1,7 @@
 import "server-only";
 import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
-import { channelOf, LEAD_SCHEMA_VERSION } from "../core/lead.js";
+import { channelOf, LEAD_CHANNELS, LEAD_SCHEMA_VERSION } from "../core/lead.js";
 import { LEAD_FLOWS } from "../core/pricing/flow.js";
 // `node:sqlite` is reached through `getBuiltinModule` rather than an import so
 // the bundler never has to resolve a builtin it may not know yet; the type is
@@ -67,6 +67,10 @@ const STEPS = [
         db.exec("ALTER TABLE leads ADD COLUMN pricing_valid_from TEXT");
         db.exec("ALTER TABLE leads ADD COLUMN estimate_inputs TEXT");
     },
+    // 8 — the reference a messenger lead's chat carries (`AQ-7K3F`), so the
+    // operator finds the lead from the message. Nullable: a row from before, a
+    // lead from a card without a reference.
+    db => db.exec("ALTER TABLE leads ADD COLUMN message_ref TEXT"),
 ];
 if (STEPS.length !== LEAD_SCHEMA_VERSION) {
     // The version belongs to the port, shared by every adapter; this table of
@@ -99,6 +103,7 @@ function leadOf(row) {
     const submissionId = str(row, "submission_id");
     const flow = LEAD_FLOWS.find(f => f === str(row, "flow"));
     const price = priceOf(row);
+    const messageRef = str(row, "message_ref");
     return {
         subject: str(row, "job") ?? "",
         locality: str(row, "zip") ?? "",
@@ -106,11 +111,12 @@ function leadOf(row) {
         extras: strings(str(row, "extras")),
         placeSlug: str(row, "location_id"),
         spamVerdict: verdict !== null && VERDICTS.includes(verdict) ? verdict : null,
-        channel: str(row, "channel") === "callback" ? "callback" : "form",
+        channel: LEAD_CHANNELS.find(c => c === str(row, "channel")) ?? "form",
         ...(consentAt !== null ? { consent: { at: consentAt, text: str(row, "consent_text") ?? "" } } : {}),
         ...(submissionId !== null ? { submissionId } : {}),
         ...(flow !== undefined ? { flow } : {}),
         ...(price !== null ? { price } : {}),
+        ...(messageRef !== null ? { messageRef } : {}),
     };
 }
 function userVersion(db) {
@@ -194,13 +200,13 @@ export function openSqliteLeadStore(path) {
         db.close();
         throw error;
     }
-    const insert = db.prepare("INSERT INTO leads (job, zip, mobile, location_id, spam_verdict, extras, channel, consent_at, consent_text, submission_id, flow, quoted_cents, pricing_valid_from, estimate_inputs) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id");
-    const bySubmission = db.prepare("SELECT id, job, zip, mobile, location_id, spam_verdict, extras, channel, consent_at, consent_text, submission_id, flow, quoted_cents, pricing_valid_from, estimate_inputs FROM leads WHERE submission_id = ?");
+    const insert = db.prepare("INSERT INTO leads (job, zip, mobile, location_id, spam_verdict, extras, channel, consent_at, consent_text, submission_id, flow, quoted_cents, pricing_valid_from, estimate_inputs, message_ref) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id");
+    const bySubmission = db.prepare("SELECT id, job, zip, mobile, location_id, spam_verdict, extras, channel, consent_at, consent_text, submission_id, flow, quoted_cents, pricing_valid_from, estimate_inputs, message_ref FROM leads WHERE submission_id = ?");
     const count = db.prepare("SELECT COUNT(*) AS n FROM leads");
     return {
         async insert(lead) {
             const extras = Object.keys(lead.extras).length > 0 ? JSON.stringify(lead.extras) : null;
-            return integer(insert.get(lead.subject, lead.locality, lead.mobile, lead.placeSlug, lead.spamVerdict, extras, channelOf(lead), lead.consent?.at ?? null, lead.consent?.text ?? null, lead.submissionId ?? null, lead.flow ?? null, lead.price?.cents ?? null, lead.price?.validFrom ?? null, lead.price?.inputs ? JSON.stringify(lead.price.inputs) : null), "id");
+            return integer(insert.get(lead.subject, lead.locality, lead.mobile, lead.placeSlug, lead.spamVerdict, extras, channelOf(lead), lead.consent?.at ?? null, lead.consent?.text ?? null, lead.submissionId ?? null, lead.flow ?? null, lead.price?.cents ?? null, lead.price?.validFrom ?? null, lead.price?.inputs ? JSON.stringify(lead.price.inputs) : null, lead.messageRef ?? null), "id");
         },
         async findSubmission(submissionId) {
             const row = bySubmission.get(submissionId);

package/dist/server/lead-webhook.d.ts

@@ -43,6 +43,18 @@ export interface LeadWebhookContext {
      * property: it refuses an unknown one, and the outbox would park the lead.
      */
     analyticsId?: string;
+    /**
+     * The lead's channel as the panel's `properties.channel` takes it
+     * (`panelChannel`): `whatsapp` and `telegram` only under `panelMessenger`,
+     * `form` otherwise. Absent only on a context built by hand.
+     */
+    channel?: PanelChannel;
+    /**
+     * The reference the visitor's chat carries (`Lead.messageRef`), for the
+     * panel's `properties.message_ref` — only under `panelMessenger`, and only
+     * on a lead that has one; otherwise absent, and the body must not carry it.
+     */
+    messageRef?: string;
 }
 /** A lead's sale as the panel's `lead.created` may carry it. */
 export interface PanelFlow {
@@ -69,14 +81,17 @@ export interface PanelFlowProperties {
     estimate_inputs?: Readonly<Record<string, string>>;
 }
 export declare function panelFlowProperties(flow: PanelFlow | undefined): PanelFlowProperties | Record<string, never>;
+/** A channel a site sends the panel; `phone_inbound` is the panel's own, for the calls it records. */
+export type PanelChannel = "form" | "callback" | "whatsapp" | "telegram";
 /**
  * A lead's channel as the Service-Arb panel's `lead.created` carries it in
- * `properties.channel` — a closed set (`form` | `phone_inbound` | `callback`)
- * that refuses the whole event outside it, so the outbox would park the lead.
- * A site's lead is a form or a callback, each its own: `phone_inbound` is the
- * panel's, for the calls it records itself. `panelChannel(channelOf(lead))`.
+ * `properties.channel` — a closed set that refuses the whole event outside
+ * it, so the outbox would park the lead. `messenger`: whether the panel takes
+ * `whatsapp` and `telegram` (`LeadWebhookOptions.panelMessenger`); until it
+ * does, a messenger lead is a `form` there — the leads table keeps the truth.
+ * `ctx.channel` is this, already decided.
  */
-export declare function panelChannel(channel: LeadChannel): "form" | "callback";
+export declare function panelChannel(channel: LeadChannel, messenger?: boolean): PanelChannel;
 /**
  * The receiver's body, built by the brand: the kit serialises and signs
  * whatever this returns and knows nothing of its shape. Called once, when the
@@ -129,6 +144,8 @@ export interface LeadWebhook {
     readonly panelFlow: boolean;
     /** Whether `requestBooking` queues anything (`LeadWebhookOptions.panelBooking`). */
     readonly panelBooking?: boolean;
+    /** Whether `ctx.channel` says `whatsapp` / `telegram` and `ctx.messageRef` is filled in (`LeadWebhookOptions.panelMessenger`). */
+    readonly panelMessenger?: boolean;
     /**
      * Queues `booking.requested@1` behind the lead's `lead.created`, through
      * the same outbox: not sent until that row is delivered, and a `409` / `425`
@@ -173,6 +190,14 @@ export interface LeadWebhookOptions extends WebhookOutboxOptions {
      * and dropped; the lead is untouched either way.
      */
     panelBooking?: boolean;
+    /**
+     * The switch for the messenger channels: `ctx.channel` says `whatsapp` or
+     * `telegram`, and `ctx.messageRef` carries the lead's reference. Off (the
+     * default) until the panel's `lead.created` accepts them — it refuses an
+     * unknown channel or property, and the outbox would park the lead: a
+     * messenger lead goes as a `form`, without its reference.
+     */
+    panelMessenger?: boolean;
     /** The body of `booking.requested@1`; absent → booking requests are dropped whatever `panelBooking` says. */
     buildBookingBody?: BuildBookingBody | undefined;
 }

package/dist/server/lead-webhook.js

@@ -1,6 +1,6 @@
 import "server-only";
 import { randomUUID } from "node:crypto";
-import { suspectOf } from "../core/lead.js";
+import { channelOf, suspectOf } from "../core/lead.js";
 import { experimentsDeclaredBody } from "./experiments-declared.js";
 import { openWebhookOutbox } from "./webhook-outbox.js";
 /** The sale `ctx.flow` describes, or nothing for a lead without a flow. */
@@ -23,12 +23,15 @@ export function panelFlowProperties(flow) {
 }
 /**
  * A lead's channel as the Service-Arb panel's `lead.created` carries it in
- * `properties.channel` — a closed set (`form` | `phone_inbound` | `callback`)
- * that refuses the whole event outside it, so the outbox would park the lead.
- * A site's lead is a form or a callback, each its own: `phone_inbound` is the
- * panel's, for the calls it records itself. `panelChannel(channelOf(lead))`.
+ * `properties.channel` — a closed set that refuses the whole event outside
+ * it, so the outbox would park the lead. `messenger`: whether the panel takes
+ * `whatsapp` and `telegram` (`LeadWebhookOptions.panelMessenger`); until it
+ * does, a messenger lead is a `form` there — the leads table keeps the truth.
+ * `ctx.channel` is this, already decided.
  */
-export function panelChannel(channel) {
+export function panelChannel(channel, messenger = false) {
+    if (channel === "whatsapp" || channel === "telegram")
+        return messenger ? channel : "form";
     return channel;
 }
 /**
@@ -37,7 +40,7 @@ export function panelChannel(channel) {
  * so a broken setting fails startup rather than a lead.
  */
 export function leadWebhook(site, env, options) {
-    const { buildBody, buildBookingBody, signing, panelSuspect = false, panelFlow = false, panelBooking = false, ...outboxOptions } = options;
+    const { buildBody, buildBookingBody, signing, panelSuspect = false, panelFlow = false, panelBooking = false, panelMessenger = false, ...outboxOptions } = options;
     if (!env.leadWebhook || !buildBody)
         return null;
     if (env.leadsDb.kind !== "sqlite")
@@ -50,6 +53,7 @@ export function leadWebhook(site, env, options) {
         panelSuspect,
         panelFlow,
         panelBooking,
+        panelMessenger,
         requestBooking(request) {
             if (!panelBooking || !buildBookingBody)
                 return { kind: "off" };
@@ -81,6 +85,8 @@ export function leadWebhook(site, env, options) {
                 idempotencyKey: randomUUID(),
                 ...(suspect ? { suspect } : {}),
                 ...(flow ? { flow } : {}),
+                channel: panelChannel(channelOf(lead), panelMessenger),
+                ...(panelMessenger && lead.messageRef ? { messageRef: lead.messageRef } : {}),
             };
             const body = JSON.stringify(buildBody(lead, ctx));
             if (typeof body !== "string")

package/dist/server/notify.js

@@ -5,16 +5,22 @@ const shownOf = (lead, needLabel) => ({ need: needLabel?.(lead.subject) ?? lead.
 /** A plain default; a brand passes `format` to write it in its own language. */
 export function defaultLeadMail(brand, lead, id, options = {}) {
     const place = lead.placeSlug ?? "unknown";
-    // A callback request is a promise to ring the customer: it says so first.
-    const callback = channelOf(lead) === "callback";
+    // A callback request is a promise to ring the customer: it says so first. A
+    // messenger lead says where the customer will write, and the reference the
+    // message carries — what the operator matches the chat by.
+    const channel = channelOf(lead);
+    const messenger = channel === "whatsapp" ? "WhatsApp" : channel === "telegram" ? "Telegram" : null;
+    const kind = channel === "callback" ? "call back" : messenger ? `${messenger} lead` : "new lead";
+    const flag = channel === "callback" ? " — CALL BACK" : messenger ? ` — ${messenger.toUpperCase()}` : "";
     return {
-        subject: `${brand.name} — ${callback ? "call back" : "new lead"} (${place})`,
+        subject: `${brand.name} — ${kind} (${place})`,
         text: [
-            `Lead #${id} — place ${place}${callback ? " — CALL BACK" : ""}${lead.spamVerdict ? ` — suspect (${lead.spamVerdict})` : ""}`,
+            `Lead #${id} — place ${place}${flag}${lead.spamVerdict ? ` — suspect (${lead.spamVerdict})` : ""}`,
             "",
+            ...(lead.messageRef ? [`Réf.     : ${lead.messageRef}`] : []),
             `Subject  : ${shownOf(lead, options.needLabel).need}`,
             `Locality : ${lead.locality}`,
-            `Mobile   : ${lead.mobile}`,
+            `Mobile   : ${lead.mobile || (messenger ? `(none — answer on ${messenger})` : "")}`,
             ...Object.entries(lead.extras).map(([name, value]) => `${name} : ${value}`),
         ].join("\n"),
     };

package/dist/testing/index.d.ts

@@ -9,5 +9,5 @@
 export { describeLandingContract, type LandingContractOptions } from "./landing-contract.js";
 export { servedPaths } from "./served-files.js";
 export { describeLeadStoreContract, type LeadStoreHarness } from "./lead-store-contract.js";
-export { leadRuleDisagreements, PHONE_MATRIX } from "./lead-rules.js";
+export { leadRuleDisagreements, messengerRuleDisagreements, PHONE_MATRIX } from "./lead-rules.js";
 export { serviceAreaPlace, storefrontPlace, testLead } from "./fixtures.js";

package/dist/testing/index.js

@@ -9,5 +9,5 @@
 export { describeLandingContract } from "./landing-contract.js";
 export { servedPaths } from "./served-files.js";
 export { describeLeadStoreContract } from "./lead-store-contract.js";
-export { leadRuleDisagreements, PHONE_MATRIX } from "./lead-rules.js";
+export { leadRuleDisagreements, messengerRuleDisagreements, PHONE_MATRIX } from "./lead-rules.js";
 export { serviceAreaPlace, storefrontPlace, testLead } from "./fixtures.js";