@evinvest/kitstart 0.16.0 → 0.18.0

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";

package/dist/testing/landing-contract.js

@@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest";
 import { isPublished, publicationGaps } from "../core/place/publication.js";
 import { createRouting, NON_PAGE_ROUTES, pointSuffixes, THANKS } from "../core/routing.js";
 import { openLaunchBlockers } from "../core/site.js";
-import { leadRuleDisagreements } from "./lead-rules.js";
+import { leadRuleDisagreements, messengerRuleDisagreements } from "./lead-rules.js";
 import { servedPaths } from "./served-files.js";
 const SOURCE_LINE = /@source\s+["'][^"']*node_modules\/@evinvest\/kitstart\/dist["']/;
 const MATCHER = "/((?!_next/).*)";
@@ -48,6 +48,11 @@ export function describeLandingContract(site, options = {}) {
         it("refuses exactly the phone numbers the form blocks", () => {
             expect(leadRuleDisagreements(site.lead)).toEqual([]);
         });
+        // A messenger lead is posted as the visitor leaves for the chat: the
+        // message carries the rest, and a refusal would be shown to no one.
+        it("takes a messenger lead without a postcode or a phone", () => {
+            expect(messengerRuleDisagreements(site.lead)).toEqual([]);
+        });
         it("publishes nothing without a domain", () => {
             if (site.brand.domain !== null)
                 return;

package/dist/testing/lead-rules.d.ts

@@ -16,3 +16,11 @@ export declare const PHONE_MATRIX: readonly {
  * a postcode — so only the phone is judged. Empty is agreement.
  */
 export declare function leadRuleDisagreements(schema: LeadSchema<string>): string[];
+/**
+ * Where a brand's form rule refuses a messenger lead it must take: one with
+ * the subject chosen and nothing else — no postcode, no phone — since the
+ * chat carries the rest and is how the business answers. And where it takes
+ * a typed number the form would block: a phone given to a messenger lead is
+ * still one the operator may call. Empty is agreement.
+ */
+export declare function messengerRuleDisagreements(schema: LeadSchema<string>): string[];

package/dist/testing/lead-rules.js

@@ -1,4 +1,4 @@
-import { readCandidate, validateCandidate } from "../core/lead.js";
+import { CHANNEL_FIELD, readCandidate, validateCandidate } from "../core/lead.js";
 import { phoneProblem } from "../core/phone.js";
 /**
  * Numbers people type, and whether each is a way to reach them — the
@@ -62,3 +62,32 @@ export function leadRuleDisagreements(schema) {
     }
     return out;
 }
+/**
+ * Where a brand's form rule refuses a messenger lead it must take: one with
+ * the subject chosen and nothing else — no postcode, no phone — since the
+ * chat carries the rest and is how the business answers. And where it takes
+ * a typed number the form would block: a phone given to a messenger lead is
+ * still one the operator may call. Empty is agreement.
+ */
+export function messengerRuleDisagreements(schema) {
+    const out = [];
+    for (const channel of ["whatsapp", "telegram"]) {
+        const bare = new FormData();
+        bare.set(schema.wire.subject, schema.subjects[0] ?? "");
+        bare.set(CHANNEL_FIELD, channel);
+        const refused = validateCandidate(schema, readCandidate(schema, bare, null));
+        if (refused)
+            out.push(`${channel}: a lead with no postcode and no phone is refused at ${refused.field} (${refused.why})`);
+        for (const { mobile } of PHONE_MATRIX) {
+            const form = new FormData();
+            form.set(schema.wire.subject, schema.subjects[0] ?? "");
+            form.set(CHANNEL_FIELD, channel);
+            form.set(schema.wire.mobile, mobile);
+            const blocked = phoneProblem(mobile) !== null;
+            const refused = validateCandidate(schema, readCandidate(schema, form, null)) !== null;
+            if (blocked !== refused)
+                out.push(`${channel} ${mobile}: the form ${blocked ? "blocks" : "takes"} it, the server ${refused ? "refuses" : "takes"} it`);
+        }
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evinvest/kitstart",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Landing-site machinery for local-service brands: a site composition root, the Place/Presence/ServiceArea model with a publication gate, host/locale routing, schema.org and SEO builders, the lead funnel with its antispam, and analytics events. Pure core at '.', more subpaths per runtime.",
   "license": "BlueOak-1.0.0",
   "publishConfig": {
@@ -126,5 +126,8 @@
     "template/proxy.ts",
     "template/app/[locale]/[location]/layout.tsx",
     "dist/cli/kitstart-size.js"
-  ]
+  ],
+  "dependencies": {
+    "qrcode-generator": "^2.0.4"
+  }
 }

package/template/app/quote/route.ts

@@ -1,6 +1,7 @@
 import { quoteRoute } from "@evinvest/kitstart/next";
 import { TEXT } from "@/entities/content";
 import { notifier, pricing, serverEnv } from "@/shared/config/env";
+import { QA_COOKIE } from "@/shared/config/experiments";
 import { site } from "@/shared/config/site";
 
 /** The no-JS path: a plain form POST answered with a 303. */
@@ -10,6 +11,8 @@ export const POST = quoteRoute(site, {
   env: serverEnv,
   notifier,
   pricing,
+  // The layout's `AnalyticsBoundary` gets the same: a QA visit's lead says `forced: true`.
+  qaCookie: QA_COOKIE,
   unavailable: locale => {
     const t = TEXT[locale];
     const f = { place: site.brand.name, phone: site.brand.phone };

package/template/flake.nix

@@ -3,7 +3,7 @@
     v_flakes.url = "github:valeratrades/v_flakes?ref=v1.6";
     # The lib flake at the tag of the @evinvest/kitstart version in
     # package-lock.json — mkLanding refuses a mismatch.
-    ev.url = "github:EV-invest/lib?ref=@evinvest/kitstart-v0.16.0";
+    ev.url = "github:EV-invest/lib?ref=@evinvest/kitstart-v0.18.0";
     ev.inputs.v_flakes.follows = "v_flakes";
   };
 

package/template/package.json

@@ -20,9 +20,9 @@
   "dependencies": {
     "@evinvest/analytics": "^0.4.0",
     "@evinvest/i18n": "^0.9.0",
-    "@evinvest/kitstart": "^0.16.0",
+    "@evinvest/kitstart": "^0.18.0",
     "@evinvest/marketing": "^0.3.0",
-    "@evinvest/uikit": "^0.26.0",
+    "@evinvest/uikit": "^0.27.0",
     "next": "16.3.6",
     "react": "19.3.0",
     "react-dom": "19.3.0",

package/template/tests/e2e/ab-switcher.spec.ts

@@ -48,6 +48,8 @@ test("a new visitor gets no menu and never fetches its panel; a test visit gets
 
 test("a variant's tap forces it by the URL; the reset drops the force and keeps the visit a test", async ({ page, context, baseURL }) => {
   await asTester(context, baseURL);
+  // Assigned `a`, as a brand's proxy assigns every running experiment: one without a cookie is off in the menu.
+  await context.addCookies([{ name: "ab_lead_form", value: "a", url: baseURL ?? "" }]);
   await page.goto("/fr?utm_source=qa");
   await chip(page).click();
   await panel(page).getByRole("button", { name: "Steps" }).click();