@evinvest/kitstart 0.9.0 → 0.11.0

package/dist/react/use-booking.d.ts

@@ -0,0 +1,20 @@
+import type { BookingRequestedProperties } from "../core/booking/model.js";
+/** A request as the page posts it; a provider outside the closed set is the server's to refuse. */
+export type PostedBooking = Omit<BookingRequestedProperties, "provider"> & {
+    provider: string;
+};
+/** Where `LeadCapture` posts a booking request: `bookingRoute`, beside the quote route. */
+export declare const BOOKING_ACTION = "/quote/booking";
+export interface BookingReport {
+    /** The visitor opened the booking (or sent a `manual` preference): the event, and `booking.requested@1` to the site. */
+    requested(properties: PostedBooking): Promise<boolean>;
+    /** The provider said the slot is booked. */
+    booked(): void;
+}
+/**
+ * The page's side of a booking: `lead_booking_open` / `lead_booking_done`
+ * (the provider only, never the URL), and the request to the site's
+ * `bookingRoute`, which the panel hears as `booking.requested@1`. The post is
+ * first-party, and the page stays: a provider's page opens in a new tab.
+ */
+export declare function useBooking(provider: string, submission: string, formId: string, action?: string): BookingReport;

package/dist/react/use-booking.js

@@ -0,0 +1,32 @@
+"use client";
+import { useCallback, useMemo } from "react";
+import { EVENTS } from "../core/analytics.js";
+import { useAnalyticsSink } from "./analytics-context.js";
+/** Where `LeadCapture` posts a booking request: `bookingRoute`, beside the quote route. */
+export const BOOKING_ACTION = "/quote/booking";
+/**
+ * The page's side of a booking: `lead_booking_open` / `lead_booking_done`
+ * (the provider only, never the URL), and the request to the site's
+ * `bookingRoute`, which the panel hears as `booking.requested@1`. The post is
+ * first-party, and the page stays: a provider's page opens in a new tab.
+ */
+export function useBooking(provider, submission, formId, action = BOOKING_ACTION) {
+    const sink = useAnalyticsSink();
+    const props = useMemo(() => ({ provider, form_id: formId }), [provider, formId]);
+    const requested = useCallback(async (properties) => {
+        sink?.capture(EVENTS.bookingOpen, props);
+        try {
+            const res = await fetch(action, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ submission, ...properties }),
+            });
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }, [sink, props, action, submission]);
+    const booked = useCallback(() => sink?.capture(EVENTS.bookingDone, props), [sink, props]);
+    return { requested, booked };
+}

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

@@ -1,11 +1,7 @@
 import { type RefObject } from "react";
-import { type LeadChannel } from "../core/lead.js";
+import { type LeadChannel, type LeadError } from "../core/lead.js";
 import type { LeadCaptureText } from "../core/lead-capture-text.js";
-/** 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;
-}
+export type { LeadError };
 /** The fields `LeadCapture` draws itself, which show a refusal under themselves. */
 export declare const OWN_FIELDS: Readonly<Record<LeadChannel, readonly string[]>>;
 /** The id of the message a refusal of a field the card does not draw is shown in, above the submit. */
@@ -21,4 +17,4 @@ export declare function errorText(field: string, text: LeadCaptureText): string;
  * `aria-invalid` and pointed at the message above the submit. Fixing that
  * control clears it.
  */
-export declare function useLeadError(root: RefObject<HTMLElement | null>, id: string): [LeadError | null, (error: LeadError | null) => void];
+export declare function useLeadError(root: RefObject<HTMLElement | null>, id: string, initial?: LeadError | null): [LeadError | null, (error: LeadError | null) => void];

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

@@ -1,7 +1,7 @@
 "use client";
 import { useEffect, useState } from "react";
-import { LEAD_ERROR_PARAM } from "../core/lead.js";
-const FIELD = /^[a-z][a-z0-9_]{0,31}$/;
+import { PRICE_CHANGED } from "../core/accept.js";
+import { LEAD_CARD_PARAM, LEAD_ERROR_FIELD, LEAD_ERROR_PARAM } from "../core/lead.js";
 /** The fields `LeadCapture` draws itself, which show a refusal under themselves. */
 export const OWN_FIELDS = { form: ["phone", "locality", "name"], callback: ["phone", "consent"] };
 /** The id of the message a refusal of a field the card does not draw is shown in, above the submit. */
@@ -31,8 +31,9 @@ function controlOf(form, field) {
  * `aria-invalid` and pointed at the message above the submit. Fixing that
  * control clears it.
  */
-export function useLeadError(root, id) {
-    const [error, setError] = useState(null);
+export function useLeadError(root, id, initial = null) {
+    // Drawn on the server too when the page read it from its query (`leadErrorOf`).
+    const [error, setError] = useState(initial);
     useEffect(() => {
         const url = new URL(window.location.href);
         const field = url.searchParams.get(LEAD_ERROR_PARAM);
@@ -40,8 +41,9 @@ export function useLeadError(root, id) {
         if (field === null || channel === null)
             return;
         url.searchParams.delete(LEAD_ERROR_PARAM);
+        url.searchParams.delete(LEAD_CARD_PARAM);
         window.history.replaceState(window.history.state, "", url);
-        if (FIELD.test(field))
+        if (LEAD_ERROR_FIELD.test(field))
             setError({ channel, field });
     }, [id]);
     useEffect(() => {
@@ -57,7 +59,8 @@ export function useLeadError(root, id) {
         foreign?.setAttribute("aria-describedby", formMessageId(id, error.channel));
         (control ?? document.getElementById(formMessageId(id, error.channel)))?.focus();
         const fixed = (event) => {
-            if (error.field === "form" || (event.target instanceof Element && control?.contains(event.target)))
+            // A refusal of the whole form, or of its price, is about every answer: any change answers it.
+            if (error.field === "form" || error.field === PRICE_CHANGED || (event.target instanceof Element && control?.contains(event.target)))
                 setError(null);
         };
         form.addEventListener("input", fixed);

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

@@ -8,6 +8,8 @@ export interface LeadEvents {
     fieldError(field: LeadField): void;
     /** The script's post got no answer: `network` or `timeout`, and which form. */
     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;
 }
 /**
  * The lead form's own funnel, reported through the boundary's sink: seen

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

@@ -1,6 +1,7 @@
 "use client";
 import { useEffect, useMemo, useRef } from "react";
 import { EVENTS, experimentProps } from "../core/analytics.js";
+import { centsBucket } from "../core/pricing/price.js";
 import { useAnalyticsSink } from "./analytics-context.js";
 /** The attribute a lead form's control names its role in, for `lead_form_field_error`. */
 export const FIELD_ATTR = "data-lead-field";
@@ -18,6 +19,7 @@ export function useLeadEvents(root, tags) {
     const variant = tags.experiment?.variant;
     const props = useMemo(() => ({ form_id: formId, layout, ...experimentProps(name, variant) }), [formId, layout, name, variant]);
     const started = useRef(false);
+    const shown = useRef(new Set());
     useEffect(() => {
         const el = root.current;
         if (!sink || !el)
@@ -59,5 +61,13 @@ export function useLeadEvents(root, tags) {
         step: step => sink?.capture(EVENTS.formStep, { ...props, step }),
         fieldError: field => sink?.capture(EVENTS.fieldError, { ...props, field, blocking: false }),
         submitError: (reason, channel) => sink?.capture(EVENTS.submitError, { ...props, reason, channel }),
+        estimateShown: (need, cents) => {
+            const cents_bucket = centsBucket(cents);
+            const key = `${need}\n${cents_bucket}`;
+            if (shown.current.has(key))
+                return;
+            shown.current.add(key);
+            sink?.capture(EVENTS.estimateShown, { ...props, need, cents_bucket });
+        },
     }), [sink, props]);
 }

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

@@ -7,6 +7,15 @@ export interface LeadSent {
     phone: string;
     /** The name field's value, when the form has one and it was filled. */
     name: string | null;
+    /** The lead's public reference, as the route answered it (`leadRef`), for a `booking` to name the lead. */
+    lead?: string;
+    /** The price the server took the lead at, for an `estimate` or `fixed` need. */
+    cents?: number;
+    /**
+     * The form's submission id, with `lead` only: the secret a booking request
+     * (`bookingRoute`) proves the lead is this page's with.
+     */
+    submission?: string;
 }
 /** Leaving the page, behind a seam a test can stand in for (jsdom cannot navigate). */
 export declare const navigation: {
@@ -23,7 +32,8 @@ export type SendFailure = "network" | "timeout";
 export declare const SUBMIT_TIMEOUT_MS = 15000;
 export interface LeadSubmitHandlers {
     /** The route refused the lead: the field to fix. */
-    onRefused: (channel: LeadChannel, field: string) => void;
+    /** `cents`: with `price_changed`, the server's fresh price. */
+    onRefused: (channel: LeadChannel, field: string, cents?: number) => void;
     /** No answer: the form stays as typed, with a retry. */
     onFailed: (channel: LeadChannel, failure: SendFailure) => void;
 }
@@ -42,15 +52,15 @@ export interface LeadSubmit {
 }
 /**
  * The lead posted by a script, so a refusal keeps what was typed: the body
- * and the endpoint are the form's own, asked for JSON. Taken → the brand's
- * in-card success when it has one (`done`), else the thanks page the route
+ * and the endpoint are the form's own, asked for JSON. Taken → the in-card
+ * success when the card has one for that channel (`done`), else the thanks page the route
  * names. Refused → `onRefused` with the field, the form as it was. No answer
  * — no network, or nothing in `SUBMIT_TIMEOUT_MS` — is said in place with a
  * retry, never by leaving the page: the browser's error page would lose the
  * 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, fields: {
+export declare function useLeadSubmit(done: boolean | ((channel: LeadChannel) => boolean), fields: {
     mobile: string;
     name: string | undefined;
 }, on: LeadSubmitHandlers): LeadSubmit;

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

@@ -41,6 +41,7 @@ function stamp(form) {
     minted.set(form, { id, lead });
     field.value = id;
 }
+const LEAD_REF = /^lead-\d+-[0-9a-f]{8}$/;
 /** A root-relative path on this origin — never `//elsewhere`. */
 const OWN_PATH = /^\/(?!\/)/;
 /**
@@ -58,11 +59,18 @@ async function readAnswer(res) {
         });
         if (typeof body !== "object" || body === null)
             return null;
-        const { ok, location, field } = body;
-        if (ok === true && typeof location === "string" && OWN_PATH.test(location))
-            return { ok, location };
+        const { ok, location, field, lead, cents } = body;
+        if (ok === true && typeof location === "string" && OWN_PATH.test(location)) {
+            return {
+                ok,
+                location,
+                ...(typeof lead === "string" && LEAD_REF.test(lead) ? { lead } : {}),
+                ...(typeof cents === "number" && Number.isSafeInteger(cents) && cents >= 0 ? { cents } : {}),
+            };
+        }
+        // `cents`: with `price_changed`, the price the lead would be taken at now.
         if (ok === false && typeof field === "string")
-            return { ok, field };
+            return { ok, field, ...(typeof cents === "number" && Number.isSafeInteger(cents) && cents >= 0 ? { cents } : {}) };
         return null;
     }
     if (res.ok && res.redirected) {
@@ -76,8 +84,8 @@ async function readAnswer(res) {
 export const SUBMIT_TIMEOUT_MS = 15_000;
 /**
  * The lead posted by a script, so a refusal keeps what was typed: the body
- * and the endpoint are the form's own, asked for JSON. Taken → the brand's
- * in-card success when it has one (`done`), else the thanks page the route
+ * and the endpoint are the form's own, asked for JSON. Taken → the in-card
+ * success when the card has one for that channel (`done`), else the thanks page the route
  * names. Refused → `onRefused` with the field, the form as it was. No answer
  * — no network, or nothing in `SUBMIT_TIMEOUT_MS` — is said in place with a
  * retry, never by leaving the page: the browser's error page would lose the
@@ -129,13 +137,15 @@ export function useLeadSubmit(done, fields, on) {
                 return fallBack();
             if (!answer.ok) {
                 settle();
-                return on.onRefused(lead.channel, answer.field);
+                return on.onRefused(lead.channel, answer.field, answer.cents);
             }
             // Still pending: the page is leaving, or the form is gone. The next
             // lead from this form (Back, another need) gets an id of its own.
             minted.delete(form);
-            if (done)
-                setSent(lead);
+            const submission = data.get(SUBMISSION_FIELD);
+            const ref = answer.lead && typeof submission === "string" && submission !== "" ? { lead: answer.lead, submission } : answer.lead ? { lead: answer.lead } : {};
+            if (typeof done === "function" ? done(lead.channel) : done)
+                setSent({ ...lead, ...ref, ...(answer.cents !== undefined ? { cents: answer.cents } : {}) });
             else
                 navigation.assign(answer.location);
         }, () => {

package/dist/react/use-repriced.d.ts

@@ -0,0 +1,18 @@
+import type { LeadCaptureFlowText } from "../core/lead-capture-text.js";
+import type { Price } from "../core/pricing/model.js";
+/**
+ * The price the server answered when the one on screen was stale
+ * (`price_changed`): shown in its place, and posted back as `shown_cents` —
+ * a resubmit is the visitor confirming it. Only while the answers are the
+ * ones it was refused for; a change and the page prices on its own again.
+ */
+export declare function useRepriced(price: Price | null, need: string | undefined, text: LeadCaptureFlowText, locale: string): {
+    /** The price to show: the server's fresh one, else the page's own. */
+    price: Price | null;
+    /** What the form posts as `shown_cents`. */
+    shownCents: number | undefined;
+    /** The words for a `price_changed` refusal, with both prices when the page has them. */
+    message: () => string;
+    /** A refusal: remembers the fresh price when it is `price_changed`. */
+    refused(field: string, cents: number | undefined): void;
+};

package/dist/react/use-repriced.js

@@ -0,0 +1,27 @@
+"use client";
+import { useState } from "react";
+import { PRICE_CHANGED } from "../core/accept.js";
+import { fillText, formatCents } from "../core/lead-capture-format.js";
+/**
+ * The price the server answered when the one on screen was stale
+ * (`price_changed`): shown in its place, and posted back as `shown_cents` —
+ * a resubmit is the visitor confirming it. Only while the answers are the
+ * ones it was refused for; a change and the page prices on its own again.
+ */
+export function useRepriced(price, need, text, locale) {
+    const [repriced, setRepriced] = useState(null);
+    const current = repriced && price && repriced.shown === price.cents && repriced.need === need ? repriced : null;
+    return {
+        /** The price to show: the server's fresh one, else the page's own. */
+        price: current ? { cents: current.cents, breakdown: [] } : price,
+        /** What the form posts as `shown_cents`. */
+        shownCents: current?.cents ?? price?.cents,
+        /** The words for a `price_changed` refusal, with both prices when the page has them. */
+        message: () => current ? fillText(text.priceChanged, { price: formatCents(current.cents, locale), shown: formatCents(current.shown, locale) }) : text.priceChangedGeneric,
+        /** A refusal: remembers the fresh price when it is `price_changed`. */
+        refused(field, cents) {
+            if (field === PRICE_CHANGED && cents !== undefined && price)
+                setRepriced({ cents, shown: price.cents, need });
+        },
+    };
+}

package/dist/server/index.d.ts

@@ -6,13 +6,14 @@
 import "server-only";
 export { createServerEnv, parseServerEnv, type EnvSource, type ServerEnv } from "./env.js";
 export { createPlaceSource, PLACE_REVALIDATE_SECONDS, PlaceSourceError, type PlaceSource, type PlaceSourceOptions } from "./place-source.js";
+export { createPricingSource, type PricingSource, type PricingSourceOptions } from "./pricing-source.js";
 export { describeLeadDb, openLeadStore, parseLeadDb, type LeadDb } from "./lead-store.js";
 export { openSqliteLeadStore, type SqliteLeadStore } from "./lead-store-sqlite.js";
 export { LeadStoreNotImplemented, openPostgresLeadStore } from "./lead-store-postgres.js";
 export { parseSmtpUrl, sendMail, type Mail, type SendOptions } from "./smtp.js";
-export { defaultLeadMail, leadNotifier, MAIL_PER_MINUTE, type LeadMail, type LeadNotifier, type NotifyEnv } from "./notify.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, type BuildWebhookBody, type LeadWebhook, type LeadWebhookContext, type LeadWebhookOptions } from "./lead-webhook.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 { 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/index.js

@@ -6,6 +6,7 @@
 import "server-only";
 export { createServerEnv, parseServerEnv } from "./env.js";
 export { createPlaceSource, PLACE_REVALIDATE_SECONDS, PlaceSourceError } from "./place-source.js";
+export { createPricingSource } from "./pricing-source.js";
 export { describeLeadDb, openLeadStore, parseLeadDb } from "./lead-store.js";
 export { openSqliteLeadStore } from "./lead-store-sqlite.js";
 export { LeadStoreNotImplemented, openPostgresLeadStore } from "./lead-store-postgres.js";
@@ -13,6 +14,6 @@ export { parseSmtpUrl, sendMail } from "./smtp.js";
 export { defaultLeadMail, leadNotifier, MAIL_PER_MINUTE } from "./notify.js";
 export { clientKey, NO_CLIENT_ADDRESS, parseProxyTrust } from "./client-key.js";
 export { checkLeadStore } from "./boot.js";
-export { leadWebhook, panelChannel } from "./lead-webhook.js";
+export { leadWebhook, panelChannel, panelFlowOf, panelFlowProperties, } from "./lead-webhook.js";
 export { checkWebhookUrl, openWebhookOutbox, WEBHOOK_HORIZON_MS, WEBHOOK_MAX_ATTEMPTS, WEBHOOK_MAX_DELAY_MS, WEBHOOK_TICK_MS, } from "./webhook-outbox.js";
 export { signatureHeaders, signWebhook } from "./webhook-signature.js";

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

@@ -2,6 +2,7 @@ import "server-only";
 import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import { channelOf, 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
 // the module's own.
@@ -57,6 +58,15 @@ const STEPS = [
         db.exec("ALTER TABLE leads ADD COLUMN submission_id TEXT");
         db.exec("CREATE UNIQUE INDEX leads_submission_id ON leads (submission_id) WHERE submission_id IS NOT NULL");
     },
+    // 7 — how the need was sold (`quote`, `estimate`, `fixed`), and for the two
+    // priced flows the server's price, the model's date and an estimate's
+    // answers (JSON). Nullable: a row from before, a callback, a quote.
+    db => {
+        db.exec("ALTER TABLE leads ADD COLUMN flow TEXT");
+        db.exec("ALTER TABLE leads ADD COLUMN quoted_cents INTEGER");
+        db.exec("ALTER TABLE leads ADD COLUMN pricing_valid_from TEXT");
+        db.exec("ALTER TABLE leads ADD COLUMN estimate_inputs TEXT");
+    },
 ];
 if (STEPS.length !== LEAD_SCHEMA_VERSION) {
     // The version belongs to the port, shared by every adapter; this table of
@@ -69,22 +79,38 @@ function str(row, key) {
     return typeof value === "string" ? value : null;
 }
 const VERDICTS = ["honeypot", "too-fast", "rate-limited"];
+/** A JSON object of strings, or `{}`: what `extras` and `estimate_inputs` hold. */
+function strings(text) {
+    const value = JSON.parse(text ?? "{}");
+    return Object.fromEntries(Object.entries(typeof value === "object" && value !== null ? value : {}).filter((e) => typeof e[1] === "string"));
+}
+function priceOf(row) {
+    const cents = column(row, "quoted_cents");
+    const validFrom = str(row, "pricing_valid_from");
+    if ((typeof cents !== "number" && typeof cents !== "bigint") || validFrom === null)
+        return null;
+    const inputs = str(row, "estimate_inputs");
+    return { cents: Number(cents), validFrom, ...(inputs !== null ? { inputs: strings(inputs) } : {}) };
+}
 /** A stored row read back as the lead it was written from. */
 function leadOf(row) {
     const verdict = str(row, "spam_verdict");
-    const extras = JSON.parse(str(row, "extras") ?? "{}");
     const consentAt = str(row, "consent_at");
     const submissionId = str(row, "submission_id");
+    const flow = LEAD_FLOWS.find(f => f === str(row, "flow"));
+    const price = priceOf(row);
     return {
         subject: str(row, "job") ?? "",
         locality: str(row, "zip") ?? "",
         mobile: str(row, "mobile") ?? "",
-        extras: Object.fromEntries(Object.entries(typeof extras === "object" && extras !== null ? extras : {}).filter((e) => typeof e[1] === "string")),
+        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",
         ...(consentAt !== null ? { consent: { at: consentAt, text: str(row, "consent_text") ?? "" } } : {}),
         ...(submissionId !== null ? { submissionId } : {}),
+        ...(flow !== undefined ? { flow } : {}),
+        ...(price !== null ? { price } : {}),
     };
 }
 function userVersion(db) {
@@ -168,13 +194,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) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id");
-    const bySubmission = db.prepare("SELECT id, job, zip, mobile, location_id, spam_verdict, extras, channel, consent_at, consent_text, submission_id 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) 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 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), "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), "id");
         },
         async findSubmission(submissionId) {
             const row = bySubmission.get(submissionId);

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

@@ -1,5 +1,7 @@
 import "server-only";
+import type { BookingRequest } from "../core/booking/model.js";
 import { type Lead, type LeadChannel, type LeadSuspect } from "../core/lead.js";
+import type { LeadFlow } from "../core/pricing/flow.js";
 import type { ServerEnv } from "./env.js";
 import { type TickReport, type WebhookOutbox, type WebhookOutboxOptions } from "./webhook-outbox.js";
 import type { WebhookSigning } from "./webhook-signature.js";
@@ -20,7 +22,44 @@ export interface LeadWebhookContext {
      * body must not carry the property at all.
      */
     suspect?: LeadSuspect;
+    /**
+     * The lead's public reference (`leadRef`, `lead-<row>-<8 hex>`): the one
+     * the page was answered with (`LeadSent.lead`), so a later step on the page
+     * can name the lead the panel knows. Absent only on a context built by hand.
+     */
+    leadRef?: string;
+    /**
+     * How the need was sold and at what price — only under `panelFlow`, and
+     * only on a lead with a flow; otherwise absent, and the body must not carry
+     * the properties. `panelFlowProperties` writes them as the panel reads them.
+     */
+    flow?: PanelFlow;
+}
+/** A lead's sale as the panel's `lead.created` may carry it. */
+export interface PanelFlow {
+    flow: LeadFlow;
+    /** With `estimate` and `fixed` only, always with `pricingValidFrom`. */
+    quotedCents?: number;
+    /** The price list's date, `YYYY-MM-DD`. */
+    pricingValidFrom?: string;
+    /** With `estimate` only, and only when it asked anything: input id → option id, slugs. */
+    estimateInputs?: Readonly<Record<string, string>>;
 }
+/** The sale `ctx.flow` describes, or nothing for a lead without a flow. */
+export declare function panelFlowOf(lead: Pick<Lead, "flow" | "price">): PanelFlow | undefined;
+/**
+ * `ctx.flow` as `lead.created`'s properties: `flow`, then `quoted_cents` and
+ * `pricing_valid_from` together (estimate and fixed), then `estimate_inputs`
+ * (estimate) — the panel's closed vocabulary. Spread into the body's
+ * `properties`; `{}` without a flow.
+ */
+export interface PanelFlowProperties {
+    flow: LeadFlow;
+    quoted_cents?: number;
+    pricing_valid_from?: string;
+    estimate_inputs?: Readonly<Record<string, string>>;
+}
+export declare function panelFlowProperties(flow: PanelFlow | undefined): PanelFlowProperties | Record<string, never>;
 /**
  * What the Service-Arb panel's `lead.created` calls a callback request. Its
  * `properties.channel` is a closed set (`form` | `phone_inbound`) and an event
@@ -37,11 +76,38 @@ export declare function panelChannel(channel: LeadChannel): "form" | typeof PANE
  * lead is queued — the stored body is what every attempt sends.
  */
 export type BuildWebhookBody = (lead: Lead, ctx: LeadWebhookContext) => unknown;
+/** What the brand's booking body builder is told besides the request. */
+export interface BookingWebhookContext {
+    brandId: string;
+    /** When the site took the request. */
+    at: Date;
+    /** Fresh per request and stored with the body, like a lead's. */
+    idempotencyKey: string;
+}
+/**
+ * `booking.requested@1`'s body, built by the brand like `BuildWebhookBody`:
+ * `bookingRequestedProperties(request)` writes the properties as the panel
+ * reads them, and `request.leadRef` is the lead id the brand's
+ * `lead.created` must have carried for the two to join.
+ */
+export type BuildBookingBody = (request: BookingRequest, ctx: BookingWebhookContext) => unknown;
+/** Why `requestBooking` queued nothing. */
+export type BookingQueued = {
+    kind: "queued";
+    row: number;
+} | {
+    kind: "off";
+} | {
+    kind: "duplicate";
+} | {
+    kind: "unqueued";
+};
 export interface LeadWebhook {
     /** Builds, serialises and queues the lead's body; returns the outbox row. */
     enqueue(lead: Lead, id: number, meta: {
         locale: string;
         formId: string;
+        leadRef?: string;
     }): number;
     tick(): Promise<TickReport>;
     start(intervalMs?: number): void;
@@ -51,6 +117,18 @@ export interface LeadWebhook {
     requeueDead(): number;
     /** Whether a suspect lead is queued, marked (`LeadWebhookOptions.panelSuspect`). */
     readonly panelSuspect: boolean;
+    /** Whether `ctx.flow` is filled in (`LeadWebhookOptions.panelFlow`). */
+    readonly panelFlow: boolean;
+    /** Whether `requestBooking` queues anything (`LeadWebhookOptions.panelBooking`). */
+    readonly panelBooking?: 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`
+     * for it retried. Once per lead: a second request is a `duplicate`,
+     * whatever it asks. `unqueued` when the lead's own row was never queued (a
+     * suspect held back); `off` without `panelBooking` or a `buildBookingBody`.
+     */
+    requestBooking?(request: BookingRequest): BookingQueued;
     readonly outbox: WebhookOutbox;
 }
 export interface LeadWebhookOptions extends WebhookOutboxOptions {
@@ -66,6 +144,22 @@ export interface LeadWebhookOptions extends WebhookOutboxOptions {
      * suspect, for the brand's body to carry.
      */
     panelSuspect?: boolean;
+    /**
+     * The switch for the sale's properties (`ctx.flow`: `flow`, `quoted_cents`,
+     * `pricing_valid_from`, `estimate_inputs`). Off (the default) until the
+     * panel's `lead.created` accepts them — it refuses an unknown property, and
+     * the outbox would park the lead. The leads table keeps them either way.
+     */
+    panelFlow?: boolean;
+    /**
+     * The switch for `booking.requested@1` (`requestBooking`). Off (the
+     * default) until the panel accepts the event type — it refuses an unknown
+     * one, and the outbox would park it. Off, a booking request is answered
+     * and dropped; the lead is untouched either way.
+     */
+    panelBooking?: boolean;
+    /** The body of `booking.requested@1`; absent → booking requests are dropped whatever `panelBooking` says. */
+    buildBookingBody?: BuildBookingBody | undefined;
 }
 /**
  * The lead webhook, or `null` when it is off: no `LEAD_WEBHOOK_URL`, or no

package/dist/server/lead-webhook.js

@@ -2,6 +2,24 @@ import "server-only";
 import { randomUUID } from "node:crypto";
 import { suspectOf } from "../core/lead.js";
 import { openWebhookOutbox } from "./webhook-outbox.js";
+/** The sale `ctx.flow` describes, or nothing for a lead without a flow. */
+export function panelFlowOf(lead) {
+    if (!lead.flow)
+        return undefined;
+    if (lead.flow === "quote" || !lead.price)
+        return { flow: "quote" };
+    const inputs = lead.flow === "estimate" && lead.price.inputs && Object.keys(lead.price.inputs).length > 0 ? { estimateInputs: lead.price.inputs } : {};
+    return { flow: lead.flow, quotedCents: lead.price.cents, pricingValidFrom: lead.price.validFrom, ...inputs };
+}
+export function panelFlowProperties(flow) {
+    if (!flow)
+        return {};
+    return {
+        flow: flow.flow,
+        ...(flow.quotedCents !== undefined && flow.pricingValidFrom !== undefined ? { quoted_cents: flow.quotedCents, pricing_valid_from: flow.pricingValidFrom } : {}),
+        ...(flow.estimateInputs ? { estimate_inputs: flow.estimateInputs } : {}),
+    };
+}
 /**
  * What the Service-Arb panel's `lead.created` calls a callback request. Its
  * `properties.channel` is a closed set (`form` | `phone_inbound`) and an event
@@ -20,7 +38,7 @@ export function panelChannel(channel) {
  * so a broken setting fails startup rather than a lead.
  */
 export function leadWebhook(site, env, options) {
-    const { buildBody, signing, panelSuspect = false, ...outboxOptions } = options;
+    const { buildBody, buildBookingBody, signing, panelSuspect = false, panelFlow = false, panelBooking = false, ...outboxOptions } = options;
     if (!env.leadWebhook || !buildBody)
         return null;
     if (env.leadsDb.kind !== "sqlite")
@@ -30,9 +48,35 @@ export function leadWebhook(site, env, options) {
     return {
         outbox,
         panelSuspect,
+        panelFlow,
+        panelBooking,
+        requestBooking(request) {
+            if (!panelBooking || !buildBookingBody)
+                return { kind: "off" };
+            // The lead's own row, as `enqueue` refs it: the booking follows it, and
+            // a lead never queued (held back as suspect) is never booked to the panel.
+            const lead = `lead:${/^lead-(\d+)-/.exec(request.leadRef)?.[1] ?? ""}`;
+            if (!outbox.hasRef(lead))
+                return { kind: "unqueued" };
+            const ctx = { brandId: site.brand.id, at: new Date(now()), idempotencyKey: randomUUID() };
+            const body = JSON.stringify(buildBookingBody(request, ctx));
+            if (typeof body !== "string")
+                throw new Error("buildBookingBody returned nothing JSON can carry");
+            const row = outbox.enqueueOnce(body, `booking:${request.leadRef}`, lead);
+            return row === null ? { kind: "duplicate" } : { kind: "queued", row };
+        },
         enqueue(lead, id, meta) {
             const suspect = panelSuspect ? suspectOf(lead) : undefined;
-            const ctx = { leadId: id, brandId: site.brand.id, ...meta, at: new Date(now()), idempotencyKey: randomUUID(), ...(suspect ? { suspect } : {}) };
+            const flow = panelFlow ? panelFlowOf(lead) : undefined;
+            const ctx = {
+                leadId: id,
+                brandId: site.brand.id,
+                ...meta,
+                at: new Date(now()),
+                idempotencyKey: randomUUID(),
+                ...(suspect ? { suspect } : {}),
+                ...(flow ? { flow } : {}),
+            };
             const body = JSON.stringify(buildBody(lead, ctx));
             if (typeof body !== "string")
                 throw new Error("buildWebhookBody returned nothing JSON can carry");