@evinvest/kitstart 0.9.0 → 0.11.0

package/dist/core/pricing/model.js

@@ -0,0 +1,34 @@
+/**
+ * A brand's price list as data: what an `estimate` need costs for a set of
+ * enum inputs, and what a `fixed` need costs outright. JSON-serialisable on
+ * purpose — the panel edits it, serves it, and prices its own preview with a
+ * port of `priceOf` held to the same fixtures (`test/fixtures/pricing/`).
+ *
+ * Money is integer euro cents, TTC, throughout; a multiplier or a discount is
+ * in basis points (10 000 = ×1, 1 000 = 10 %), so no float ever reaches a
+ * stored or sent number.
+ */
+/** The model's format; a model of another format is refused whole. */
+export const PRICING_FORMAT = 1;
+/** The only currency a model may be in today: euros, all taxes included. */
+export const PRICING_CURRENCY = "EUR";
+/**
+ * The model's limits. Ids are slugs (they travel to the panel as
+ * `estimate_inputs`, which takes at most 12 pairs); every amount, and every
+ * step of the dearest combination, stays at or under `MAX_PRICE_CENTS`, so
+ * each product fits a double exactly and a 64-bit integer with room to spare.
+ */
+export const PRICING_LIMITS = {
+    slug: /^[a-z0-9_-]{1,40}$/,
+    locale: /^[a-z]{2}(-[A-Z]{2})?$/,
+    maxLabel: 120,
+    maxInputs: 32,
+    maxOptions: 32,
+    maxNeeds: 64,
+    /** Per need: what `estimate_inputs` may carry. */
+    maxNeedInputs: 12,
+    maxPriceCents: 100_000_000,
+    /** ×10 at most. */
+    maxMultiplyBp: 100_000,
+    maxDiscountBp: 10_000,
+};

package/dist/core/pricing/price.d.ts

@@ -0,0 +1,34 @@
+import type { Price, PricingInputs, PricingModel } from "./model.js";
+/**
+ * `cents × bp / 10 000`, rounded half up to the cent. Integers throughout:
+ * the product is exact (the model's limits keep it under 2^53), and the
+ * division is done on the remainder, never on a float.
+ */
+export declare function mulBp(cents: number, bp: number): number;
+/** Half up to a multiple of `step` (≥ 1). */
+export declare function roundTo(cents: number, step: number): number;
+/**
+ * What a need costs for these answers — the one function the form shows and
+ * the server stores, and the one the panel's preview ports. Normative order:
+ *
+ * 1. the need's base, plus every `add` input, in the need's input order;
+ * 2. times every `multiply` input, in order, each product rounded half up to
+ *    the cent at once;
+ * 3. less every `discount` input, in order, each as a multiplication by
+ *    `10 000 − discountBp` rounded the same way;
+ * 4. the total rounded half up to a multiple of `roundToCents`;
+ * 5. raised to `minimumCents`.
+ *
+ * A `fixed` need is its price, as is. `null`: the need is not priced, or an
+ * input is unanswered or answered with an option it does not have — never a
+ * guess. Answers to inputs the need does not ask are ignored.
+ */
+export declare function priceOf(model: PricingModel, need: string, inputs: PricingInputs): Price | null;
+/**
+ * The band a price falls in, for analytics: `"5000-7500"` (cents, lower
+ * bound included), never the price itself — a funnel needs the shape of
+ * what was shown, not a number that, with a time and a place, singles a
+ * visitor out.
+ */
+export declare const CENTS_BUCKETS: readonly number[];
+export declare function centsBucket(cents: number): string;

package/dist/core/pricing/price.js

@@ -0,0 +1,105 @@
+const BP = 10_000;
+/**
+ * `cents × bp / 10 000`, rounded half up to the cent. Integers throughout:
+ * the product is exact (the model's limits keep it under 2^53), and the
+ * division is done on the remainder, never on a float.
+ */
+export function mulBp(cents, bp) {
+    const n = cents * bp + BP / 2;
+    return (n - (n % BP)) / BP;
+}
+/** Half up to a multiple of `step` (≥ 1). */
+export function roundTo(cents, step) {
+    const rest = cents % step;
+    return rest * 2 >= step ? cents - rest + step : cents - rest;
+}
+/** The option answered for each of the need's inputs, or `null` when one is missing or unknown. */
+function chosen(model, ids, inputs) {
+    const out = [];
+    for (const id of ids) {
+        const input = model.inputs.find(i => i.id === id);
+        const answer = Object.hasOwn(inputs, id) ? inputs[id] : undefined;
+        if (!input || answer === undefined)
+            return null;
+        const effect = effectOf(input, answer);
+        if (effect === null)
+            return null;
+        out.push({ input, option: answer, effect });
+    }
+    return out;
+}
+function effectOf(input, option) {
+    switch (input.kind) {
+        case "add":
+            return input.options.find(o => o.id === option)?.addCents ?? null;
+        case "multiply":
+            return input.options.find(o => o.id === option)?.multiplyBp ?? null;
+        case "discount":
+            return input.options.find(o => o.id === option)?.discountBp ?? null;
+    }
+}
+/**
+ * What a need costs for these answers — the one function the form shows and
+ * the server stores, and the one the panel's preview ports. Normative order:
+ *
+ * 1. the need's base, plus every `add` input, in the need's input order;
+ * 2. times every `multiply` input, in order, each product rounded half up to
+ *    the cent at once;
+ * 3. less every `discount` input, in order, each as a multiplication by
+ *    `10 000 − discountBp` rounded the same way;
+ * 4. the total rounded half up to a multiple of `roundToCents`;
+ * 5. raised to `minimumCents`.
+ *
+ * A `fixed` need is its price, as is. `null`: the need is not priced, or an
+ * input is unanswered or answered with an option it does not have — never a
+ * guess. Answers to inputs the need does not ask are ignored.
+ */
+export function priceOf(model, need, inputs) {
+    const pricing = Object.hasOwn(model.needs, need) ? model.needs[need] : undefined;
+    if (!pricing)
+        return null;
+    if (pricing.kind === "fixed")
+        return { cents: pricing.cents, breakdown: [{ kind: "base", cents: pricing.cents }] };
+    const answers = chosen(model, pricing.inputs, inputs);
+    if (!answers)
+        return null;
+    const lines = [{ kind: "base", cents: pricing.baseCents }];
+    let total = pricing.baseCents;
+    const step = (kind, apply) => {
+        for (const a of answers) {
+            if (a.input.kind !== kind)
+                continue;
+            const next = apply(total, a.effect);
+            lines.push({ kind, input: a.input.id, option: a.option, cents: next - total });
+            total = next;
+        }
+    };
+    step("add", (t, cents) => t + cents);
+    step("multiply", (t, bp) => mulBp(t, bp));
+    step("discount", (t, bp) => mulBp(t, BP - bp));
+    const rounded = roundTo(total, model.roundToCents);
+    if (rounded !== total)
+        lines.push({ kind: "rounding", cents: rounded - total });
+    total = rounded;
+    if (total < model.minimumCents) {
+        lines.push({ kind: "minimum", cents: model.minimumCents - total });
+        total = model.minimumCents;
+    }
+    return { cents: total, breakdown: lines };
+}
+/**
+ * The band a price falls in, for analytics: `"5000-7500"` (cents, lower
+ * bound included), never the price itself — a funnel needs the shape of
+ * what was shown, not a number that, with a time and a place, singles a
+ * visitor out.
+ */
+export const CENTS_BUCKETS = [0, 2_500, 5_000, 7_500, 10_000, 15_000, 20_000, 30_000, 50_000, 100_000];
+export function centsBucket(cents) {
+    let at = 0;
+    for (let i = 0; i < CENTS_BUCKETS.length; i++)
+        if (cents >= (CENTS_BUCKETS[i] ?? 0))
+            at = i;
+    const low = CENTS_BUCKETS[at] ?? 0;
+    const high = CENTS_BUCKETS[at + 1];
+    return high === undefined ? `${low}+` : `${low}-${high}`;
+}

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

@@ -0,0 +1,27 @@
+import { type PricingLabels, type PricingModel } from "./model.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 declare class PricingModelError extends Error {
+    readonly problems: readonly string[];
+    readonly name = "PricingModelError";
+    constructor(problems: readonly string[]);
+}
+/**
+ * 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 declare function pricingProblems(value: unknown): string[];
+/** The model `value` is, rebuilt from what was checked; throws `PricingModelError` with every problem. */
+export declare function parsePricingModel(value: unknown): PricingModel;
+/**
+ * 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 declare function pricingProblemsFor(value: unknown, locales: readonly string[]): string[];
+/** The label for `locale`, or the first one the model has. */
+export declare function labelOf(labels: PricingLabels, locale: string): string;

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/routing.d.ts

@@ -66,8 +66,9 @@ export declare function parseGoneHeader(value: string | null): {
 };
 /**
  * The routes every landing has outside `[locale]`, which pass untouched: the
- * form target, the OG card, the probe, the sitemap and robots. Anything else
- * without a language but `/_next/…` and the site's `publicFiles` is `gone`.
+ * form target, its booking request (`bookingRoute`) and its price
+ * confirmation (`confirmRoute`), the OG card, the probe, the sitemap and robots. Anything else without a language but
+ * `/_next/…` and the site's `publicFiles` is `gone`.
  */
 export declare const NON_PAGE_ROUTES: readonly string[];
 /** @deprecated The same list as {@link NON_PAGE_ROUTES}, under its old name. */

package/dist/core/routing.js

@@ -70,10 +70,11 @@ export function parseGoneHeader(value) {
 }
 /**
  * The routes every landing has outside `[locale]`, which pass untouched: the
- * form target, the OG card, the probe, the sitemap and robots. Anything else
- * without a language but `/_next/…` and the site's `publicFiles` is `gone`.
+ * form target, its booking request (`bookingRoute`) and its price
+ * confirmation (`confirmRoute`), the OG card, the probe, the sitemap and robots. Anything else without a language but
+ * `/_next/…` and the site's `publicFiles` is `gone`.
  */
-export const NON_PAGE_ROUTES = ["/quote", "/og", "/health", "/sitemap.xml", "/robots.txt"];
+export const NON_PAGE_ROUTES = ["/quote", "/quote/booking", "/quote/confirm", "/og", "/health", "/sitemap.xml", "/robots.txt"];
 /** @deprecated The same list as {@link NON_PAGE_ROUTES}, under its old name. */
 export const PASS_PATHS = NON_PAGE_ROUTES;
 function isInfrastructure(pathname, publicFiles) {

package/dist/core/site.d.ts

@@ -1,7 +1,9 @@
 import type { LocaleRegistry } from "@evinvest/i18n";
+import type { BookingRules } from "./booking/model.js";
 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 +64,19 @@ 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;
+    /**
+     * The booking rules a place's `booking` is held to, baked or live:
+     * `calComHosts` are the Cal.com hosts a `cal_com` page may be on — the
+     * hosted cloud by default (`DEFAULT_CAL_COM_HOSTS`); a brand on its own
+     * Cal.com lists both, `["cal.com", "cal.brand.fr"]`.
+     */
+    booking?: BookingRules;
     legacyRedirects?: readonly LegacyRedirect<L>[];
     /**
      * Paths the brand serves as files besides the routes every landing has

package/dist/core/site.js

@@ -1,3 +1,5 @@
+import { bookingConfigProblems, calComHostsProblems } from "./booking/validate.js";
+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 +30,30 @@ 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("; ")}`);
+    }
+    const calComHosts = config.booking?.calComHosts;
+    if (calComHosts) {
+        const problems = calComHostsProblems(calComHosts);
+        if (problems.length > 0)
+            throw new Error(`defineSite: booking.${problems.join("; ")}`);
+    }
+    for (const place of config.places) {
+        // Baked into the build: a booking the live source would refuse must not ship.
+        if (place.booking === undefined)
+            continue;
+        const problems = bookingConfigProblems(place.booking, config.booking ?? {});
+        if (problems.length > 0)
+            throw new Error(`defineSite: place "${place.slug}": ${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/index.d.ts

@@ -6,17 +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 { 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 LeadRejection, type LeadSchema, type LeadStore, type LeadSuspect, type LeadVerdict, type LeadWire, type SpamVerdict, } from "./core/lead.js";
+export { CARD_FIELD, CARD_ID, CHANNEL_FIELD, channelOf, CONSENT_FIELD, LEAD_CHANNELS, LEAD_ERROR_PARAM, LEAD_CARD_PARAM, leadErrorFor, leadErrorOf, LEAD_SCHEMA_VERSION, MAX_CONSENT, MAX_FIELD, readCandidate, rejectionOf, suspectOf, SUBMISSION_FIELD, SUBMISSION_ID, validateCallbackLead, validateCandidate, validateLead, type Lead, type LeadCandidate, type LeadChannel, type LeadError, type PageLeadError, 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 { LEAD_CAPTURE_TEXT, type LeadCaptureText } from "./core/lead-capture-text.js";
-export { fillText, openingText } from "./core/lead-capture-format.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, PRICE_CHANGED, SHOWN_CENTS_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 { BOOKING_LIMITS, BOOKING_PROVIDERS, BOOKING_STATUSES, BookingConfigError, bookingConfigProblems, BOOKING_EXPERIMENT, bookingHref, bookingOf, bookingRequestedProperties, bookingRequestProblems, calComHostsProblems, DEFAULT_BOOKING, DEFAULT_CAL_COM_HOSTS, isBookingProvider, isLeadRef, isPageProvider, isPreferredPart, parseBookingConfig, parseBookingRequest, PREFERRED_PARTS, type BookingChoice, type BookingConfig, type BookingPrefill, type BookingProvider, type BookingRequest, type BookingRequestedProperties, type BookingRules, type BookingStatus, type OpenBookingConfig, type PageProvider, type PreferredPart, } from "./core/booking/index.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";

package/dist/index.js

@@ -6,16 +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 { 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 { CARD_FIELD, CARD_ID, CHANNEL_FIELD, channelOf, CONSENT_FIELD, LEAD_CHANNELS, LEAD_ERROR_PARAM, LEAD_CARD_PARAM, leadErrorFor, leadErrorOf, 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 { LEAD_CAPTURE_TEXT } from "./core/lead-capture-text.js";
-export { fillText, openingText } from "./core/lead-capture-format.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, PRICE_CHANGED, SHOWN_CENTS_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 { BOOKING_LIMITS, BOOKING_PROVIDERS, BOOKING_STATUSES, BookingConfigError, bookingConfigProblems, BOOKING_EXPERIMENT, bookingHref, bookingOf, bookingRequestedProperties, bookingRequestProblems, calComHostsProblems, DEFAULT_BOOKING, DEFAULT_CAL_COM_HOSTS, isBookingProvider, isLeadRef, isPageProvider, isPreferredPart, parseBookingConfig, parseBookingRequest, PREFERRED_PARTS, } from "./core/booking/index.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.

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

@@ -0,0 +1,31 @@
+import type { LeadStore } from "../core/lead.js";
+import type { ServerEnv } from "../server/env.js";
+import type { LeadWebhook } from "../server/lead-webhook.js";
+/**
+ * `app/quote/booking/route.ts` — the page's word that a priced lead asked for
+ * a slot: `booking.requested@1` to the panel, after the lead's `lead.created`,
+ * through the same outbox. `LeadCapture` posts it when the visitor opens a
+ * booking page (`link`, `cal_com`) or sends a `manual` preference.
+ *
+ * ```ts
+ * export const dynamic = "force-dynamic";
+ * export const POST = bookingRoute({ env: serverEnv, webhook });
+ * ```
+ *
+ * The body is JSON: `booking.requested@1`'s properties (`lead_ref`,
+ * `provider`, `preferred_date?`, `preferred_part?`) plus `submission`, the
+ * form's submission id. The id is what proves the post comes from the page
+ * that sent the lead: it is a random UUID only that page knew, and the lead's
+ * reference is derived from it — a guessed `lead_ref` alone books nothing.
+ * Answers `200 { ok: true, queued }`; `queued` is `false` when the switch is
+ * off (`panelBooking`) or the lead already asked.
+ */
+export interface BookingRouteDeps {
+    env: () => Pick<ServerEnv, "leadsDb">;
+    /** The same webhook the quote route queues `lead.created` on. */
+    webhook?: () => LeadWebhook | null;
+    store?: () => LeadStore;
+    now?: () => number;
+    log?: Pick<Console, "warn" | "error">;
+}
+export declare function bookingRoute(deps: BookingRouteDeps): (request: Request) => Promise<Response>;