@evinvest/kitstart 0.9.0 → 0.10.0

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

@@ -0,0 +1,129 @@
+/**
+ * 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 declare const PRICING_FORMAT = 1;
+/** The only currency a model may be in today: euros, all taxes included. */
+export declare const PRICING_CURRENCY = "EUR";
+/** A label per locale (`{ fr: "Studio", en: "Studio" }`); the page picks its own. */
+export type PricingLabels = Readonly<Record<string, string>>;
+/** One choice of an input: its slug, its words, and what it does to the price. */
+export interface AddOption {
+    id: string;
+    labels: PricingLabels;
+    /** Added to the base, in cents. */
+    addCents: number;
+}
+export interface MultiplyOption {
+    id: string;
+    labels: PricingLabels;
+    /** The subtotal times this, in basis points: 11 000 is ×1.1. */
+    multiplyBp: number;
+}
+export interface DiscountOption {
+    id: string;
+    labels: PricingLabels;
+    /** Taken off the subtotal, in basis points: 1 000 is 10 % off, 0 none. */
+    discountBp: number;
+}
+/**
+ * An enum the visitor answers — bedrooms, a surface band, a zone, a
+ * frequency. Its `kind` says what its options do, and when (see `priceOf`):
+ * every `add` first, then every `multiply`, then every `discount`.
+ */
+export type PricingInput = {
+    id: string;
+    kind: "add";
+    labels: PricingLabels;
+    options: readonly AddOption[];
+} | {
+    id: string;
+    kind: "multiply";
+    labels: PricingLabels;
+    options: readonly MultiplyOption[];
+} | {
+    id: string;
+    kind: "discount";
+    labels: PricingLabels;
+    options: readonly DiscountOption[];
+};
+export type PricingInputKind = PricingInput["kind"];
+/**
+ * How one need is priced. `estimate`: a base and the inputs the visitor
+ * answers, in the order the form asks them. `fixed`: one price, exactly —
+ * neither rounded nor raised to the minimum, which are the estimate's.
+ */
+export type NeedPricing = {
+    kind: "estimate";
+    baseCents: number;
+    inputs: readonly string[];
+} | {
+    kind: "fixed";
+    cents: number;
+};
+export interface PricingModel {
+    format: typeof PRICING_FORMAT;
+    currency: typeof PRICING_CURRENCY;
+    /** The date the prices hold from, `YYYY-MM-DD` — stored with every lead priced by it. */
+    validFrom: string;
+    /** The estimate's total is rounded half up to a multiple of this (1 = to the cent). */
+    roundToCents: number;
+    /** An estimate never comes out below this, after the rounding. */
+    minimumCents: number;
+    inputs: readonly PricingInput[];
+    /** By the brand's subject slug; a need not here is a `quote`. */
+    needs: Readonly<Record<string, NeedPricing>>;
+}
+/** The answers to an estimate's inputs: input id → option id. */
+export type PricingInputs = Readonly<Record<string, string>>;
+/**
+ * One line of how a price was reached; `cents` is what the line changed, so
+ * the lines add up to the total. `base` is the need's base (or the fixed
+ * price); `rounding` and `minimum` appear only when they changed something.
+ */
+export type PriceLine = {
+    kind: "base";
+    cents: number;
+} | {
+    kind: "add" | "multiply" | "discount";
+    input: string;
+    option: string;
+    cents: number;
+} | {
+    kind: "rounding";
+    cents: number;
+} | {
+    kind: "minimum";
+    cents: number;
+};
+export interface Price {
+    cents: number;
+    breakdown: readonly PriceLine[];
+}
+/**
+ * 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 declare const PRICING_LIMITS: {
+    readonly slug: RegExp;
+    readonly locale: RegExp;
+    readonly maxLabel: 120;
+    readonly maxInputs: 32;
+    readonly maxOptions: 32;
+    readonly maxNeeds: 64;
+    /** Per need: what `estimate_inputs` may carry. */
+    readonly maxNeedInputs: 12;
+    readonly maxPriceCents: 100000000;
+    /** ×10 at most. */
+    readonly maxMultiplyBp: 100000;
+    readonly maxDiscountBp: 10000;
+};

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

@@ -6,13 +6,14 @@
 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_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 { 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, 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";

package/dist/index.js

@@ -8,11 +8,12 @@ export { createPlaceView, DEFAULT_TIME_ZONE, freshRating, isOpenAt, nextOpening,
 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 { 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, 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";