@evinvest/kitstart 0.8.0 → 0.10.0

package/dist/core/pricing/validate.js

@@ -0,0 +1,244 @@
+import { PRICING_CURRENCY, PRICING_FORMAT, PRICING_LIMITS as LIMIT, } from "./model.js";
+import { mulBp } from "./price.js";
+/**
+ * A model that does not validate, with every reason found. A model is taken
+ * whole or not at all: one bad field refuses it, so a page never prices from
+ * half a model.
+ */
+export class PricingModelError extends Error {
+    problems;
+    name = "PricingModelError";
+    constructor(problems) {
+        super(`pricing model: ${problems.join("; ")}`);
+        this.problems = problems;
+    }
+}
+const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** Collects problems at a path, so the panel's editor can say which field. */
+class Check {
+    problems = [];
+    fail(path, why) {
+        this.problems.push(`${path}: ${why}`);
+    }
+    /** Only these keys, all of them required unless listed as optional. */
+    keys(path, v, required, optional = []) {
+        for (const key of required)
+            if (!Object.hasOwn(v, key))
+                this.fail(`${path}.${key}`, "missing");
+        for (const key of Object.keys(v))
+            if (!required.includes(key) && !optional.includes(key))
+                this.fail(`${path}.${key}`, "unknown field");
+    }
+    int(path, v, min, max) {
+        if (typeof v !== "number" || !Number.isSafeInteger(v) || v < min || v > max) {
+            this.fail(path, `an integer from ${min} to ${max}`);
+            return min;
+        }
+        return v;
+    }
+    slug(path, v) {
+        if (typeof v !== "string" || !LIMIT.slug.test(v)) {
+            this.fail(path, "a slug, [a-z0-9_-]{1,40}");
+            return "";
+        }
+        return v;
+    }
+    labels(path, v) {
+        if (!isObject(v) || Object.keys(v).length === 0) {
+            this.fail(path, "an object of labels by locale, at least one");
+            return {};
+        }
+        const out = {};
+        for (const [locale, text] of Object.entries(v)) {
+            if (!LIMIT.locale.test(locale))
+                this.fail(`${path}.${locale}`, "not a locale (fr, en, fr-FR)");
+            else if (typeof text !== "string" || text.trim() === "" || text.length > LIMIT.maxLabel)
+                this.fail(`${path}.${locale}`, `a label of 1 to ${LIMIT.maxLabel} characters`);
+            else
+                out[locale] = text;
+        }
+        return out;
+    }
+    list(path, v, min, max) {
+        if (!Array.isArray(v) || v.length < min || v.length > max) {
+            this.fail(path, `a list of ${min} to ${max}`);
+            return [];
+        }
+        return v;
+    }
+    unique(path, ids) {
+        const dup = ids.find((id, i) => id !== "" && ids.indexOf(id) !== i);
+        if (dup !== undefined)
+            this.fail(path, `"${dup}" is listed twice`);
+    }
+}
+/** `YYYY-MM-DD`, and a day the calendar has. */
+function isDate(v) {
+    if (typeof v !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(v))
+        return false;
+    const day = new Date(`${v}T00:00:00Z`);
+    return !Number.isNaN(day.getTime()) && day.toISOString().slice(0, 10) === v;
+}
+const EFFECT = { add: "addCents", multiply: "multiplyBp", discount: "discountBp" };
+const EFFECT_MAX = { add: LIMIT.maxPriceCents, multiply: LIMIT.maxMultiplyBp, discount: LIMIT.maxDiscountBp };
+function input(c, path, v) {
+    if (!isObject(v)) {
+        c.fail(path, "an object");
+        return null;
+    }
+    c.keys(path, v, ["id", "kind", "labels", "options"]);
+    const id = c.slug(`${path}.id`, v.id);
+    const labels = c.labels(`${path}.labels`, v.labels);
+    const kind = v.kind;
+    if (kind !== "add" && kind !== "multiply" && kind !== "discount") {
+        c.fail(`${path}.kind`, "add, multiply or discount");
+        return null;
+    }
+    const effect = EFFECT[kind];
+    const options = c.list(`${path}.options`, v.options, 1, LIMIT.maxOptions).map((o, i) => {
+        const at = `${path}.options[${i}]`;
+        if (!isObject(o)) {
+            c.fail(at, "an object");
+            return { id: "", labels: {}, value: 0 };
+        }
+        c.keys(at, o, ["id", "labels", effect]);
+        return { id: c.slug(`${at}.id`, o.id), labels: c.labels(`${at}.labels`, o.labels), value: c.int(`${at}.${effect}`, o[effect], 0, EFFECT_MAX[kind]) };
+    });
+    c.unique(`${path}.options`, options.map(o => o.id));
+    switch (kind) {
+        case "add":
+            return { id, kind, labels, options: options.map(o => ({ id: o.id, labels: o.labels, addCents: o.value })) };
+        case "multiply":
+            return { id, kind, labels, options: options.map(o => ({ id: o.id, labels: o.labels, multiplyBp: o.value })) };
+        case "discount":
+            return { id, kind, labels, options: options.map(o => ({ id: o.id, labels: o.labels, discountBp: o.value })) };
+    }
+}
+function need(c, path, v, inputs) {
+    if (!isObject(v)) {
+        c.fail(path, "an object");
+        return null;
+    }
+    if (v.kind === "fixed") {
+        c.keys(path, v, ["kind", "cents"]);
+        return { kind: "fixed", cents: c.int(`${path}.cents`, v.cents, 0, LIMIT.maxPriceCents) };
+    }
+    if (v.kind !== "estimate") {
+        c.fail(`${path}.kind`, "estimate or fixed");
+        return null;
+    }
+    c.keys(path, v, ["kind", "baseCents", "inputs"]);
+    const baseCents = c.int(`${path}.baseCents`, v.baseCents, 0, LIMIT.maxPriceCents);
+    const ids = c.list(`${path}.inputs`, v.inputs, 0, LIMIT.maxNeedInputs).map((id, i) => c.slug(`${path}.inputs[${i}]`, id));
+    c.unique(`${path}.inputs`, ids);
+    for (const [i, id] of ids.entries())
+        if (id !== "" && !inputs.some(input => input.id === id))
+            c.fail(`${path}.inputs[${i}]`, `no input "${id}"`);
+    return { kind: "estimate", baseCents, inputs: ids };
+}
+/**
+ * The dearest answer to every input — each effect only raises the price with
+ * its value, and rounding half up is monotonic — walked step by step: if no
+ * step of it passes the cap, no combination does.
+ */
+function dearest(c, path, pricing, inputs) {
+    const asked = pricing.inputs.map(id => inputs.find(i => i.id === id)).filter((i) => i !== undefined);
+    const max = (i) => Math.max(...i.options.map(o => ("addCents" in o ? o.addCents : "multiplyBp" in o ? o.multiplyBp : 0)));
+    let total = pricing.baseCents;
+    const steps = [total];
+    for (const i of asked)
+        if (i.kind === "add")
+            steps.push((total += max(i)));
+    for (const i of asked)
+        if (i.kind === "multiply")
+            steps.push((total = mulBp(total, max(i))));
+    if (steps.some(s => s > LIMIT.maxPriceCents))
+        c.fail(path, `its dearest combination passes ${LIMIT.maxPriceCents} cents`);
+}
+/**
+ * Every reason `value` is not a pricing model, or none. The panel's editor
+ * holds a model to the same rules (`test/fixtures/pricing/`): unknown fields
+ * are refused, not ignored, so the two never disagree on what a model says.
+ */
+export function pricingProblems(value) {
+    return check(value).problems;
+}
+function check(value) {
+    const c = new Check();
+    if (!isObject(value))
+        return { problems: ["model: an object"], model: null };
+    c.keys("model", value, ["format", "currency", "validFrom", "roundToCents", "minimumCents", "inputs", "needs"]);
+    if (value.format !== PRICING_FORMAT)
+        c.fail("model.format", `${PRICING_FORMAT}`);
+    if (value.currency !== PRICING_CURRENCY)
+        c.fail("model.currency", PRICING_CURRENCY);
+    if (!isDate(value.validFrom))
+        c.fail("model.validFrom", "a date, YYYY-MM-DD");
+    const roundToCents = c.int("model.roundToCents", value.roundToCents, 1, LIMIT.maxPriceCents);
+    const minimumCents = c.int("model.minimumCents", value.minimumCents, 0, LIMIT.maxPriceCents);
+    const inputs = c
+        .list("model.inputs", value.inputs, 0, LIMIT.maxInputs)
+        .map((v, i) => input(c, `model.inputs[${i}]`, v))
+        .filter((i) => i !== null);
+    c.unique("model.inputs", inputs.map(i => i.id));
+    const needs = {};
+    if (!isObject(value.needs))
+        c.fail("model.needs", "an object by need slug");
+    else {
+        const entries = Object.entries(value.needs);
+        if (entries.length > LIMIT.maxNeeds)
+            c.fail("model.needs", `at most ${LIMIT.maxNeeds}`);
+        for (const [slug, v] of entries) {
+            const path = `model.needs.${slug}`;
+            if (!LIMIT.slug.test(slug))
+                c.fail(path, "the need must be a slug, [a-z0-9_-]{1,40}");
+            const pricing = need(c, path, v, inputs);
+            if (pricing)
+                needs[slug] = pricing;
+        }
+    }
+    if (c.problems.length > 0)
+        return { problems: c.problems, model: null };
+    for (const [slug, pricing] of Object.entries(needs))
+        if (pricing.kind === "estimate")
+            dearest(c, `model.needs.${slug}`, pricing, inputs);
+    if (c.problems.length > 0)
+        return { problems: c.problems, model: null };
+    return {
+        problems: [],
+        model: { format: PRICING_FORMAT, currency: PRICING_CURRENCY, validFrom: String(value.validFrom), roundToCents, minimumCents, inputs, needs },
+    };
+}
+/** The model `value` is, rebuilt from what was checked; throws `PricingModelError` with every problem. */
+export function parsePricingModel(value) {
+    const { problems, model } = check(value);
+    if (!model)
+        throw new PricingModelError(problems);
+    return model;
+}
+/**
+ * A model a site can show: valid, and labelled in every one of its locales —
+ * the panel may serve a model before a language is filled in, and a page
+ * must not show an option with no words.
+ */
+export function pricingProblemsFor(value, locales) {
+    const { problems, model } = check(value);
+    if (!model)
+        return problems;
+    const out = [];
+    const labelled = (path, labels) => {
+        for (const locale of locales)
+            if (!Object.hasOwn(labels, locale))
+                out.push(`${path}.labels: no "${locale}" label`);
+    };
+    for (const [i, inp] of model.inputs.entries()) {
+        labelled(`model.inputs[${i}]`, inp.labels);
+        for (const [j, o] of inp.options.entries())
+            labelled(`model.inputs[${i}].options[${j}]`, o.labels);
+    }
+    return out;
+}
+/** The label for `locale`, or the first one the model has. */
+export function labelOf(labels, locale) {
+    return (Object.hasOwn(labels, locale) ? labels[locale] : undefined) ?? Object.values(labels)[0] ?? "";
+}

package/dist/core/site.d.ts

@@ -2,6 +2,7 @@ import type { LocaleRegistry } from "@evinvest/i18n";
 import type { LeadSchema } from "./lead.js";
 import type { PublicationPolicy } from "./place/publication.js";
 import type { Place } from "./place/types.js";
+import type { PricingModel } from "./pricing/model.js";
 /**
  * The composition root of a landing site: every brand fact the machinery reads
  * — routing, the lead funnel, schema.org, analytics, mail — arrives through one
@@ -62,6 +63,12 @@ export interface SiteConfig<L extends string, P extends string> {
     publication: PublicationPolicy;
     /** What the quote form asks and what a lead must have. */
     lead: LeadSchema<string>;
+    /**
+     * The baked price list: what `estimate` and `fixed` needs (`lead.flows`)
+     * are priced from when the live source (`createPricingSource`) is absent,
+     * down, or serves nothing valid. Absent → every need is a `quote` then.
+     */
+    pricing?: PricingModel;
     legacyRedirects?: readonly LegacyRedirect<L>[];
     /**
      * Paths the brand serves as files besides the routes every landing has

package/dist/core/site.js

@@ -1,3 +1,4 @@
+import { pricingProblemsFor } from "./pricing/validate.js";
 export function defineSite(config) {
     const pageKeys = Object.keys(config.pages).filter((k) => Object.hasOwn(config.pages, k));
     if (!pageKeys.includes("home"))
@@ -28,6 +29,16 @@ export function defineSite(config) {
         if (config.i18n.isLocale(file.split("/")[1] ?? ""))
             throw new Error(`defineSite: public file "${file}" must not sit under a language`);
     }
+    if (config.pricing) {
+        // Baked into the build: a model the live source would refuse must not ship.
+        const problems = pricingProblemsFor(config.pricing, config.i18n.locales);
+        if (problems.length > 0)
+            throw new Error(`defineSite: pricing: ${problems.join("; ")}`);
+    }
+    for (const need of Object.keys(config.lead.flows ?? {})) {
+        if (!config.lead.subjects.includes(need))
+            throw new Error(`defineSite: lead.flows names "${need}", which is not one of lead.subjects`);
+    }
     if (config.topology.kind === "single" && !placeSlugs.includes(config.topology.place)) {
         throw new Error(`defineSite: topology.place "${config.topology.place}" is not one of the places`);
     }

package/dist/core/status.d.ts

@@ -1,3 +1,4 @@
+import { type LeadChannel } from "./lead.js";
 import type { Place } from "./place/types.js";
 import { type Site } from "./site.js";
 /**
@@ -16,6 +17,16 @@ export interface StatusTarget<L extends string> {
     retry: string;
     langHrefs: Record<L, string>;
 }
+/**
+ * The thanks page's suffix: a callback's carries `?channel=callback`, so the
+ * page can promise a call instead of the quote's SMS.
+ */
+export declare function thanksSuffix(channel?: LeadChannel): string;
+/**
+ * Which lead the thanks page thanks for, from its query — a page's
+ * `searchParams` or a `URLSearchParams`. Anything but `callback` is `form`.
+ */
+export declare function thanksChannel(search: URLSearchParams | Readonly<Record<string, string | string[] | undefined>>): LeadChannel;
 /**
  * The brand's own status target from two facts — for a client boundary
  * (`error.tsx`, the `notFound()` boundary), which must not import the site
@@ -27,6 +38,7 @@ export declare function brandStatusTarget<L extends string>(facts: {
 }, locale: L, options?: {
     retry?: string;
     thanks?: boolean;
+    channel?: LeadChannel;
 }): StatusTarget<L>;
 /**
  * Server side — the global not-found page, a thank-you page: the target for
@@ -44,4 +56,5 @@ export declare function statusTarget<L extends string, P extends string>(site: S
 }, options?: {
     retry?: string;
     thanks?: boolean;
+    channel?: LeadChannel;
 }): StatusTarget<L>;

package/dist/core/status.js

@@ -1,6 +1,23 @@
+import { CHANNEL_FIELD } from "./lead.js";
 import { createPlaceView } from "./place/view.js";
 import { parsePlaceParam, THANKS } from "./routing.js";
 import { bakedPlace, contactOf, perLocale } from "./site.js";
+/**
+ * The thanks page's suffix: a callback's carries `?channel=callback`, so the
+ * page can promise a call instead of the quote's SMS.
+ */
+export function thanksSuffix(channel = "form") {
+    return channel === "callback" ? `${THANKS}?${CHANNEL_FIELD}=callback` : THANKS;
+}
+/**
+ * Which lead the thanks page thanks for, from its query — a page's
+ * `searchParams` or a `URLSearchParams`. Anything but `callback` is `form`.
+ */
+export function thanksChannel(search) {
+    const raw = search instanceof URLSearchParams ? search.get(CHANNEL_FIELD) : search[CHANNEL_FIELD];
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    return value === "callback" ? "callback" : "form";
+}
 function complete(r, locales) {
     return locales.every(l => typeof r[l] === "string");
 }
@@ -10,7 +27,7 @@ function complete(r, locales) {
  * config: it would carry every place into every page's bundle.
  */
 export function brandStatusTarget(facts, locale, options = {}) {
-    const suffix = options.thanks ? THANKS : "";
+    const suffix = options.thanks ? thanksSuffix(options.channel) : "";
     const langHrefs = {};
     for (const l of facts.locales)
         langHrefs[l] = `/${l}${suffix}`;
@@ -37,7 +54,7 @@ export function brandStatusTarget(facts, locale, options = {}) {
  */
 export function statusTarget(site, params, options = {}) {
     const locale = typeof params.locale === "string" && site.i18n.isLocale(params.locale) ? params.locale : site.i18n.defaultLocale;
-    const suffix = options.thanks ? THANKS : "";
+    const suffix = options.thanks ? thanksSuffix(options.channel) : "";
     const param = typeof params.location === "string" ? parsePlaceParam(params.location) : null;
     const place = param ? (bakedPlace(site, param.slug) ?? null) : null;
     if (place && param) {

package/dist/index.d.ts

@@ -6,18 +6,19 @@
 export { assertLaunchable, bakedPlace, cardFact, contactOf, defineSite, ogLocaleOf, openLaunchBlockers, perLocale, type BrandFacts, type LegacyRedirect, type OwnerTodo, type PageSuffix, type Site, type SiteConfig, type Topology, } from "./core/site.js";
 export { createPlaceView, DEFAULT_TIME_ZONE, freshRating, isOpenAt, nextOpening, parseInstant, isPublished, mergeLive, parsePlaceLive, placeHref, placeOrigin, placeUrl, publicationGaps, RATING_MAX_AGE_DAYS, servedLocalities, SERVICE_AREA_GATE, siteOrigin, STOREFRONT_GATE, storefrontOf, type DayOfWeek, type Geo, type LinkBase, type LinkMode, type Opening, type OpeningHours, type OriginFacts, type Place, type PlaceLive, type PlaceView, type PostalAddress, type Presence, type PublicationField, type PublicationPolicy, type Rating, type ServiceArea, } from "./core/place/index.js";
 export { createRouting, GONE, GONE_HEADER, gonePath, goneHeader, HOST_MARK, LANG_COOKIE, LANG_COOKIE_MAX_AGE, NON_PAGE_ROUTES, parseGoneHeader, parsePlaceParam, PASS_PATHS, placeParam, pointSuffixes, THANKS, type Decision, type RequestFacts, type Routing, } from "./core/routing.js";
-export { CHANNEL_FIELD, channelOf, CONSENT_FIELD, LEAD_CHANNELS, LEAD_SCHEMA_VERSION, MAX_CONSENT, MAX_FIELD, readCandidate, validateCallbackLead, validateCandidate, type Lead, type LeadCandidate, type LeadChannel, type LeadConsent, type LeadExtra, type LeadSchema, type LeadStore, type LeadWire, type SpamVerdict, } from "./core/lead.js";
-export { isMobilePhone, isPlausiblePhone, normalizePhone } from "./core/phone.js";
-export { LEAD_CAPTURE_TEXT, type LeadCaptureText } from "./core/lead-capture-text.js";
-export { fillText, openingText } from "./core/lead-capture-format.js";
+export { CARD_FIELD, CARD_ID, CHANNEL_FIELD, channelOf, CONSENT_FIELD, LEAD_CHANNELS, LEAD_ERROR_PARAM, LEAD_SCHEMA_VERSION, MAX_CONSENT, MAX_FIELD, readCandidate, rejectionOf, suspectOf, SUBMISSION_FIELD, SUBMISSION_ID, validateCallbackLead, validateCandidate, validateLead, type Lead, type LeadCandidate, type LeadChannel, type LeadConsent, type LeadExtra, type LeadPrice, type LeadRejection, type LeadSchema, type LeadStore, type LeadSuspect, type LeadVerdict, type LeadWire, type SpamVerdict, } from "./core/lead.js";
+export { isMobilePhone, isPlausiblePhone, normalizePhone, phoneProblem } from "./core/phone.js";
+export { CENTS_BUCKETS, centsBucket, ESTIMATE_FIELD_PREFIX, estimateField, flowOf, labelOf, LEAD_FLOWS, mulBp, parsePricingModel, priceOf, PRICING_CURRENCY, PRICING_FORMAT, PRICING_LIMITS, PricingModelError, pricingProblems, pricingProblemsFor, readEstimateInputs, roundTo, type AddOption, type DiscountOption, type LeadFlow, type LeadFlows, type MultiplyOption, type NeedPricing, type Price, type PriceLine, type PricingInput, type PricingInputKind, type PricingInputs, type PricingLabels, type PricingModel, } from "./core/pricing/index.js";
+export { flowTextOf, LEAD_CAPTURE_TEXT, type LeadCaptureFlowText, type LeadCaptureText } from "./core/lead-capture-text.js";
+export { fillText, formatCents, openingText } from "./core/lead-capture-format.js";
 export { channelHref, resolveChannels, smsHref, type CaptureChannel, type ChannelFacts, type ChannelOptions, type ResolvedChannels, } from "./core/channels.js";
 export { checkTiming, HONEYPOT_FIELD, LEGACY_HONEYPOT_FIELDS, MIN_FILL_MS, RATE_LIMIT_MAX_KEYS, RateLimiter, RENDERED_AT_FIELD, screen, type Screening, } from "./core/antispam.js";
-export { createAcceptLead, EXPERIMENT_FIELD, FORM_ID_FIELD, LOCALE_FIELD, LOCATION_FIELD, VARIANT_FIELD, type AcceptDeps, type Outcome, type SubmitTags, } from "./core/accept.js";
+export { createAcceptLead, EXPERIMENT_FIELD, FORM_ID_FIELD, leadRef, LOCALE_FIELD, LOCATION_FIELD, VARIANT_FIELD, type AcceptDeps, type Outcome, type SubmitTags, } from "./core/accept.js";
 export { areaServedNodes, breadcrumbNode, businessId, businessNode, faqPageNode, offerNodes, organizationId, organizationNode, placeGraph, websiteId, type OfferInput, type PageGraphCopy, type QuestionAnswer, } from "./core/seo/ld.js";
 export { AI_CRAWLERS, ogImageUrl, robotsFor, sitemapFor, type RobotsFile, type RobotsRule, type SitemapEntry, } from "./core/seo/sitemap.js";
 export { ALLOWED_PROPS, analyticsSink, countsAsPageView, EVENTS, EXPERIMENT_SLUG, experimentProps, type AnalyticsTarget, type IntentChannel, type LeadField, type LeadStep, } from "./core/analytics.js";
 export type { CallBarText, CopySlice, CoreText, PageMetaCopy, QuoteFormCopy, Said, StatusAction, StatusCopy, StatusScreenText, } from "./core/content.js";
-export { brandStatusTarget, statusTarget, type StatusTarget } from "./core/status.js";
+export { brandStatusTarget, statusTarget, thanksChannel, thanksSuffix, type StatusTarget } from "./core/status.js";
 export { createLocaleRegistry, type LocaleRegistry } from "@evinvest/i18n";
 export { contactChannel, ldCompact, localBusiness, telHref, whatsappHref, type ContactChannel, type JsonLdNode, } from "@evinvest/marketing";
 export { createBeaconSink, noopSink, type AnalyticsSink } from "@evinvest/analytics";

package/dist/index.js

@@ -6,17 +6,18 @@
 export { assertLaunchable, bakedPlace, cardFact, contactOf, defineSite, ogLocaleOf, openLaunchBlockers, perLocale, } from "./core/site.js";
 export { createPlaceView, DEFAULT_TIME_ZONE, freshRating, isOpenAt, nextOpening, parseInstant, isPublished, mergeLive, parsePlaceLive, placeHref, placeOrigin, placeUrl, publicationGaps, RATING_MAX_AGE_DAYS, servedLocalities, SERVICE_AREA_GATE, siteOrigin, STOREFRONT_GATE, storefrontOf, } from "./core/place/index.js";
 export { createRouting, GONE, GONE_HEADER, gonePath, goneHeader, HOST_MARK, LANG_COOKIE, LANG_COOKIE_MAX_AGE, NON_PAGE_ROUTES, parseGoneHeader, parsePlaceParam, PASS_PATHS, placeParam, pointSuffixes, THANKS, } from "./core/routing.js";
-export { CHANNEL_FIELD, channelOf, CONSENT_FIELD, LEAD_CHANNELS, LEAD_SCHEMA_VERSION, MAX_CONSENT, MAX_FIELD, readCandidate, validateCallbackLead, validateCandidate, } from "./core/lead.js";
-export { isMobilePhone, isPlausiblePhone, normalizePhone } from "./core/phone.js";
-export { LEAD_CAPTURE_TEXT } from "./core/lead-capture-text.js";
-export { fillText, openingText } from "./core/lead-capture-format.js";
+export { CARD_FIELD, CARD_ID, CHANNEL_FIELD, channelOf, CONSENT_FIELD, LEAD_CHANNELS, LEAD_ERROR_PARAM, LEAD_SCHEMA_VERSION, MAX_CONSENT, MAX_FIELD, readCandidate, rejectionOf, suspectOf, SUBMISSION_FIELD, SUBMISSION_ID, validateCallbackLead, validateCandidate, validateLead, } from "./core/lead.js";
+export { isMobilePhone, isPlausiblePhone, normalizePhone, phoneProblem } from "./core/phone.js";
+export { CENTS_BUCKETS, centsBucket, ESTIMATE_FIELD_PREFIX, estimateField, flowOf, labelOf, LEAD_FLOWS, mulBp, parsePricingModel, priceOf, PRICING_CURRENCY, PRICING_FORMAT, PRICING_LIMITS, PricingModelError, pricingProblems, pricingProblemsFor, readEstimateInputs, roundTo, } from "./core/pricing/index.js";
+export { flowTextOf, LEAD_CAPTURE_TEXT } from "./core/lead-capture-text.js";
+export { fillText, formatCents, openingText } from "./core/lead-capture-format.js";
 export { channelHref, resolveChannels, smsHref, } from "./core/channels.js";
 export { checkTiming, HONEYPOT_FIELD, LEGACY_HONEYPOT_FIELDS, MIN_FILL_MS, RATE_LIMIT_MAX_KEYS, RateLimiter, RENDERED_AT_FIELD, screen, } from "./core/antispam.js";
-export { createAcceptLead, EXPERIMENT_FIELD, FORM_ID_FIELD, LOCALE_FIELD, LOCATION_FIELD, VARIANT_FIELD, } from "./core/accept.js";
+export { createAcceptLead, EXPERIMENT_FIELD, FORM_ID_FIELD, leadRef, LOCALE_FIELD, LOCATION_FIELD, VARIANT_FIELD, } from "./core/accept.js";
 export { areaServedNodes, breadcrumbNode, businessId, businessNode, faqPageNode, offerNodes, organizationId, organizationNode, placeGraph, websiteId, } from "./core/seo/ld.js";
 export { AI_CRAWLERS, ogImageUrl, robotsFor, sitemapFor, } from "./core/seo/sitemap.js";
 export { ALLOWED_PROPS, analyticsSink, countsAsPageView, EVENTS, EXPERIMENT_SLUG, experimentProps, } from "./core/analytics.js";
-export { brandStatusTarget, statusTarget } from "./core/status.js";
+export { brandStatusTarget, statusTarget, thanksChannel, thanksSuffix } from "./core/status.js";
 // A landing needs these beside the machinery; re-exported by name so a brand
 // imports one package and the list here is the whole surface.
 export { createLocaleRegistry } from "@evinvest/i18n";

package/dist/next/quote-route.d.ts

@@ -5,13 +5,19 @@ import { type Site } from "../core/site.js";
 import type { ServerEnv } from "../server/env.js";
 import type { LeadWebhook } from "../server/lead-webhook.js";
 import type { LeadNotifier } from "../server/notify.js";
+import type { PricingSource } from "../server/pricing-source.js";
 /**
  * `app/quote/route.ts` — the no-JS path, and the one that has to keep working:
  * a plain form POST answered with a 303, so a refresh does not resubmit.
+ * A refused lead goes back to its card with the field to fix
+ * (`/fr?lead_error=phone#devis`); a script asking for JSON (`Accept:
+ * application/json`) is answered `422 { ok: false, field }` instead, and
+ * `200 { ok: true, location, lead, cents? }` for a lead taken — `lead` its
+ * public reference (`leadRef`), `cents` the price the server took it at.
  *
  * ```ts
  * export const dynamic = "force-dynamic";
- * export const POST = quoteRoute(site, { env: serverEnv, notifier, webhook, unavailable });
+ * export const POST = quoteRoute(site, { env: serverEnv, notifier, webhook, unavailable, anchor: "devis" });
  * ```
  */
 export interface UnavailableCopy {
@@ -21,7 +27,8 @@ export interface UnavailableCopy {
     callLabel: string;
 }
 export interface QuoteRouteDeps<L extends string> {
-    env: () => Pick<ServerEnv, "leadsDb" | "posthogKey" | "posthogHost" | "trustedProxy">;
+    /** `production` and `leadRateLimit` may be left out (a test's env): production's limit, no development warnings. */
+    env: () => Pick<ServerEnv, "leadsDb" | "posthogKey" | "posthogHost" | "trustedProxy"> & Partial<Pick<ServerEnv, "production" | "leadRateLimit">>;
     /** Built once (and at boot, by the brand) so a missing sender fails startup, not a lead. */
     notifier: () => LeadNotifier;
     /**
@@ -33,9 +40,22 @@ export interface QuoteRouteDeps<L extends string> {
     webhook?: () => LeadWebhook | null;
     /** The self-contained 500's words, when the store refused the lead. */
     unavailable: (locale: L, place: Place<L> | null) => UnavailableCopy;
+    /**
+     * The price list an `estimate` or `fixed` lead is priced from — the same
+     * source the page showed (`createPricingSource`); absent → `site.pricing`.
+     */
+    pricing?: PricingSource;
     /** Opened on first use (`next build` imports the route); defaults to `LEADS_DB_URL`'s. */
     store?: () => LeadStore;
+    /** Defaults to `env().leadRateLimit`, built on the first lead. */
     limiter?: RateLimiter;
+    /**
+     * The card's id a refused lead is sent back to, when the form did not post
+     * its own (`card`, which `LeadCapture` does): `quote` by default, the
+     * `LeadCapture` default. A slug, `[a-z0-9-]`; a callback lands on
+     * `<anchor>-callback`.
+     */
+    anchor?: string;
     /** Work after the response; `after` from `next/server` by default. */
     defer?: (task: () => Promise<void> | void) => void;
     now?: () => number;

package/dist/next/quote-route.js

@@ -1,11 +1,12 @@
 import { after } from "next/server.js";
-import { createAcceptLead } from "../core/accept.js";
-import { analyticsSink, EVENTS } from "../core/analytics.js";
+import { createAcceptLead, EXPERIMENT_FIELD, VARIANT_FIELD } from "../core/accept.js";
+import { analyticsSink, EVENTS, experimentProps } from "../core/analytics.js";
 import { RateLimiter } from "../core/antispam.js";
-import { channelOf } from "../core/lead.js";
+import { CARD_FIELD, CARD_ID, channelOf, LEAD_ERROR_PARAM } from "../core/lead.js";
 import { createPlaceView } from "../core/place/view.js";
-import { createRouting, THANKS } from "../core/routing.js";
+import { createRouting } from "../core/routing.js";
 import { bakedPlace, contactOf } from "../core/site.js";
+import { thanksSuffix } from "../core/status.js";
 import { clientKey } from "../server/client-key.js";
 import { openLeadStore } from "../server/lead-store.js";
 /** The Rust server's body limit; a quote is a few short fields. */
@@ -49,10 +50,22 @@ const escape = (s) => s.replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", "
 function seeOther(location) {
     return new Response(null, { status: 303, headers: { Location: location } });
 }
+function json(status, body) {
+    return new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json", "Cache-Control": "no-store" } });
+}
+const text = (form, name) => {
+    const value = form.get(name);
+    return typeof value === "string" ? value : null;
+};
+/** `LeadCapture`'s own post asks for JSON; a plain form post never does. */
+const wantsJson = (request) => (request.headers.get("accept") ?? "").includes("application/json");
 export function quoteRoute(site, deps) {
+    const anchor = deps.anchor ?? "quote";
+    if (!CARD_ID.test(anchor))
+        throw new Error(`quoteRoute: the anchor must be a slug ([a-z0-9-]), got ${JSON.stringify(anchor)}`);
     const accept = createAcceptLead(site);
     const routing = createRouting(site);
-    const limiter = deps.limiter ?? new RateLimiter(5, 10 * 60_000);
+    let limiter = deps.limiter;
     const defer = deps.defer ?? after;
     const log = deps.log ?? console;
     let store;
@@ -66,6 +79,16 @@ export function quoteRoute(site, deps) {
         }
         return webhook;
     };
+    // Read before the lead is stored, so a webhook that cannot be built must
+    // not throw here: it would cost the lead. `enqueue` says why, after the insert.
+    const suspectQueued = () => {
+        try {
+            return leadWebhook()?.panelSuspect ?? false;
+        }
+        catch {
+            return false;
+        }
+    };
     const leadStore = () => {
         store ??= deps.store ? deps.store() : openLeadStore(deps.env().leadsDb);
         return store;
@@ -80,6 +103,20 @@ export function quoteRoute(site, deps) {
         const mode = routing.hostSlug(request.headers.get("host") ?? "") === place.slug ? "host" : "path";
         return createPlaceView(site, place, locale, mode).href(suffix);
     }
+    /**
+     * Back to the card, with the field to fix and the need already chosen —
+     * slugs only: a phone or a name in a URL ends up in logs and analytics. The
+     * card is the one the form posted, if its id is a slug.
+     */
+    function refused(form, field, channel) {
+        const query = new URLSearchParams({ [LEAD_ERROR_PARAM]: field });
+        const subject = form.get(site.lead.wire.subject);
+        if (channel === "form" && typeof subject === "string" && site.lead.subjects.includes(subject))
+            query.set("need", subject);
+        const posted = form.get(CARD_FIELD);
+        const card = typeof posted === "string" && CARD_ID.test(posted) ? posted : anchor;
+        return `?${query}#${card}${channel === "callback" ? "-callback" : ""}`;
+    }
     /** Self-contained: the thing that failed may be the thing that renders pages. */
     function unavailable(slug, locale) {
         const place = (slug ? bakedPlace(site, slug) : undefined) ?? null;
@@ -109,6 +146,9 @@ export function quoteRoute(site, deps) {
         }
         const outcome = await accept(form, clientKey(request.headers, env.trustedProxy ?? DEV_TRUST), {
             insert: lead => leadStore().insert(lead),
+            findSubmission: async (submissionId) => (await leadStore().findSubmission?.(submissionId)) ?? null,
+            sendSuspect: suspectQueued(),
+            ...(deps.pricing ? { pricing: () => deps.pricing?.model() ?? Promise.resolve(null) } : {}),
             defer,
             notify: (lead, id) => {
                 notifier ??= deps.notifier();
@@ -126,16 +166,38 @@ export function quoteRoute(site, deps) {
                 channel: channelOf(lead),
                 ...tags,
             }),
-            limiter,
+            limiter: (limiter ??= new RateLimiter(env.leadRateLimit?.limit ?? 5, env.leadRateLimit?.windowMs ?? 600_000)),
             now: deps.now?.() ?? Date.now(),
             log,
         });
+        const held = outcome.kind === "stored" && !outcome.duplicate && (outcome.lead.spamVerdict === "honeypot" || (outcome.lead.spamVerdict === "rate-limited" && !suspectQueued()));
+        if (held && outcome.kind === "stored" && env.production === false) {
+            // A local stack posts every test lead from one address: say it, loudly.
+            log.warn(`\n!!! quote (development): lead ${outcome.id} stored as ${outcome.lead.spamVerdict} and NOT sent on — no mail, no webhook.\n` +
+                (outcome.lead.spamVerdict === "rate-limited"
+                    ? `!!! The visitor saw the thanks page. Raise LEAD_RATE_LIMIT (<count>/<seconds>, now ${env.leadRateLimit?.limit ?? 5}/${(env.leadRateLimit?.windowMs ?? 600_000) / 1000}) for a local stack.\n`
+                    : "!!! The visitor saw the thanks page. The hidden trap field was filled — a browser's autofill, or a test filling every field.\n"));
+        }
+        const scripted = wantsJson(request);
         switch (outcome.kind) {
             // A suspected bot is answered exactly as a person is.
-            case "stored":
-                return seeOther(href(request, outcome.lead.placeSlug, outcome.locale, THANKS));
-            case "invalid":
-                return seeOther(href(request, outcome.slug, outcome.locale, outcome.slug ? "#quote" : ""));
+            case "stored": {
+                const location = href(request, outcome.lead.placeSlug, outcome.locale, thanksSuffix(channelOf(outcome.lead)));
+                const price = outcome.lead.price ? { cents: outcome.lead.price.cents } : {};
+                return scripted ? json(200, { ok: true, location, lead: outcome.ref, ...price }) : seeOther(location);
+            }
+            case "invalid": {
+                const tags = experimentProps(text(form, EXPERIMENT_FIELD), text(form, VARIANT_FIELD));
+                // The field's role and why — never what was typed.
+                const props = { form_id: outcome.formId, channel: outcome.channel, field: outcome.field, reason: "invalid", ...tags };
+                if (env.posthogKey) {
+                    const sink = analyticsSink({ key: env.posthogKey, host: env.posthogHost, brandId: site.brand.id }, outcome.slug);
+                    defer(() => sink.capture(EVENTS.formReject, props));
+                }
+                if (scripted)
+                    return json(422, { ok: false, field: outcome.field });
+                return seeOther(href(request, outcome.slug, outcome.locale, refused(form, outcome.field, outcome.channel)));
+            }
             case "failed":
                 return unavailable(outcome.slug, outcome.locale);
         }