@pagefront/lint-commerce 0.7.0 → 0.8.0

package/dist/rules/configurator-pricing.js

@@ -0,0 +1,349 @@
+export function asObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+/** Own-property lookup: option keys are publisher strings (`constructor`, …). */
+export function own(obj, key) {
+    return obj !== null && Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
+}
+const CONTROL_ESCAPES = {
+    "\b": "\\b",
+    "\f": "\\f",
+    "\n": "\\n",
+    "\r": "\\r",
+    "\t": "\\t",
+};
+/**
+ * A name selector in the engine's path style (RFC 9535 normalized
+ * paths). Option keys are publisher strings, so the quote, the
+ * backslash and control characters are escaped as the RFC prescribes.
+ */
+export function seg(key) {
+    const escaped = key.replace(/[\\'\u0000-\u001f]/g, (ch) => {
+        if (ch === "\\" || ch === "'")
+            return `\\${ch}`;
+        return CONTROL_ESCAPES[ch] ?? `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}`;
+    });
+    return `['${escaped}']`;
+}
+const PLAIN_DECIMAL = /^(-?)(\d+)(?:\.(\d+))?$/;
+/**
+ * A decimal reading of an amount: a plain decimal string, or a JSON
+ * number whose shortest serialization is a plain decimal. Anything else
+ * is not comparable and yields undefined.
+ */
+export function parseDecimal(value) {
+    let text;
+    if (typeof value === "string")
+        text = value;
+    else if (typeof value === "number" && Number.isFinite(value))
+        text = String(value);
+    else
+        return undefined;
+    const m = PLAIN_DECIMAL.exec(text);
+    if (m === null)
+        return undefined;
+    const fraction = m[3] ?? "";
+    const units = BigInt(m[2] + fraction);
+    return { units: m[1] === "-" ? -units : units, scale: fraction.length };
+}
+function rescale(d, scale) {
+    return d.units * 10n ** BigInt(scale - d.scale);
+}
+export function addDecimal(a, b) {
+    const scale = Math.max(a.scale, b.scale);
+    return { units: rescale(a, scale) + rescale(b, scale), scale };
+}
+/** Negative, zero or positive as `a` is below, equal to or above `b`. */
+export function compareDecimal(a, b) {
+    const scale = Math.max(a.scale, b.scale);
+    const diff = rescale(a, scale) - rescale(b, scale);
+    return diff < 0n ? -1 : diff > 0n ? 1 : 0;
+}
+export function isZero(d) {
+    return d.units === 0n;
+}
+/** Renders with the decimal's own number of places (`859.00` at scale 2). */
+export function formatDecimal(d) {
+    const negative = d.units < 0n;
+    const digits = (negative ? -d.units : d.units).toString().padStart(d.scale + 1, "0");
+    const whole = digits.slice(0, digits.length - d.scale);
+    const fraction = d.scale > 0 ? `.${digits.slice(digits.length - d.scale)}` : "";
+    return `${negative ? "-" : ""}${whole}${fraction}`;
+}
+// ---------------------------------------------------------------------------
+// The configurator and the pricing block
+// ---------------------------------------------------------------------------
+/** The string form an option value is matched by (Definitions: *option key*). */
+export function optionKey(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return JSON.stringify(value);
+    return undefined;
+}
+function selection(value) {
+    const obj = asObject(value);
+    if (obj === null)
+        return null;
+    const out = new Map();
+    for (const [name, raw] of Object.entries(obj)) {
+        const key = optionKey(raw);
+        if (key === undefined)
+            return null;
+        out.set(name, key);
+    }
+    return out;
+}
+/** The Sheet's `pagefront:configurator`, or null when absent or shapeless. */
+export function readConfigurator(sheet) {
+    const raw = asObject(own(asObject(sheet.data), "pagefront:configurator"));
+    if (raw === null || !Array.isArray(raw["dimensions"]))
+        return null;
+    const dimensions = [];
+    const byName = new Map();
+    for (const entry of raw["dimensions"]) {
+        const d = asObject(entry);
+        if (d === null || typeof d["name"] !== "string")
+            continue;
+        let optionKeys = null;
+        if (Array.isArray(d["options"]) && d["options"].length > 0) {
+            optionKeys = [];
+            for (const option of d["options"]) {
+                const key = optionKey(asObject(option)?.["value"]);
+                if (key !== undefined && !optionKeys.includes(key))
+                    optionKeys.push(key);
+            }
+        }
+        const dimension = { name: d["name"], priced: d["affectsPrice"] !== false, optionKeys };
+        dimensions.push(dimension);
+        if (!byName.has(dimension.name))
+            byName.set(dimension.name, dimension);
+    }
+    const exclusions = [];
+    if (Array.isArray(raw["exclusions"])) {
+        for (const entry of raw["exclusions"]) {
+            const pairs = selection(entry);
+            if (pairs !== null && pairs.size > 0)
+                exclusions.push(pairs);
+        }
+    }
+    const id = typeof raw["@id"] === "string" ? raw["@id"] : undefined;
+    return { id, dimensions, byName, exclusions };
+}
+export function hasPricedDimension(configurator) {
+    return configurator.dimensions.some((d) => d.priced);
+}
+/** The pricing block of an `offers` entry, or null. */
+export function pricingBlock(offer) {
+    return asObject(own(asObject(offer), "pagefront:configuratorPricing"));
+}
+/** The `configurator.@id` a pricing block names, when it is a string. */
+export function pricedConfiguratorId(block) {
+    const id = own(asObject(block["configurator"]), "@id");
+    return typeof id === "string" ? id : undefined;
+}
+/**
+ * The configurator a pricing block prices: the Sheet's configurator when
+ * the block's reference equals its `@id` by exact string match. Null is
+ * the unresolved reference PDP-E-001 reports; the pricing rules are
+ * silent on it.
+ */
+export function resolveConfigurator(block, sheet) {
+    const configurator = readConfigurator(sheet);
+    const id = pricedConfiguratorId(block);
+    if (configurator === null || id === undefined || configurator.id !== id)
+        return null;
+    return configurator;
+}
+export function offerEntries(sheet) {
+    const offers = own(asObject(sheet.data), "offers");
+    return Array.isArray(offers) ? offers : [];
+}
+/**
+ * True when an `offers` entry states a price, in the sense PDP-W-033 and
+ * PDP-W-034 share: an `AggregateOffer`, or an `Offer` with `price` or a
+ * non-empty `priceSpecification`. Price-on-request offers state none.
+ */
+export function entryStatesPrice(entry) {
+    const o = asObject(entry);
+    if (o === null || o["pagefront:priceOnRequest"] !== undefined)
+        return false;
+    if (o["@type"] === "AggregateOffer")
+        return true;
+    if (o["price"] !== undefined)
+        return true;
+    const spec = o["priceSpecification"];
+    if (Array.isArray(spec))
+        return spec.length > 0;
+    return asObject(spec) !== null && Object.keys(spec).length > 0;
+}
+export function isComplete(block) {
+    return block["pricing"] !== "partial";
+}
+/** PDP-E-007's findings: omitted dimensions first, then pairs in document order. */
+export function baseConfigurationProblems(configurator, block) {
+    const base = asObject(block["baseConfiguration"]) ?? {};
+    const problems = [];
+    for (const d of configurator.dimensions) {
+        if (d.priced && d.optionKeys !== null && own(base, d.name) === undefined) {
+            problems.push({ kind: "omitted", dimension: d.name });
+        }
+    }
+    for (const [name, raw] of Object.entries(base)) {
+        const d = configurator.byName.get(name);
+        if (d === undefined) {
+            problems.push({ kind: "unknown-dimension", dimension: name });
+            continue;
+        }
+        if (!d.priced)
+            continue; // redundant pair, changes no total
+        const key = optionKey(raw);
+        if (key === undefined || d.optionKeys === null || !d.optionKeys.includes(key)) {
+            problems.push({ kind: "unknown-option", dimension: name, value: key ?? JSON.stringify(raw) });
+        }
+    }
+    return problems;
+}
+/** PDP-W-032's findings, whatever the block's `pricing` value. */
+export function missingModifierProblems(configurator, block) {
+    const modifiers = asObject(block["modifiers"]);
+    const problems = [];
+    for (const d of configurator.dimensions) {
+        if (!d.priced)
+            continue;
+        if (d.optionKeys === null) {
+            problems.push({ kind: "no-options", dimension: d.name });
+            continue;
+        }
+        const entry = asObject(own(modifiers, d.name));
+        for (const option of d.optionKeys) {
+            if (own(entry, option) === undefined) {
+                problems.push({ kind: "missing", dimension: d.name, option });
+            }
+        }
+    }
+    return problems;
+}
+function matches(pairs, configuration) {
+    for (const [name, key] of pairs) {
+        if (configuration.get(name) !== key)
+            return false;
+    }
+    return true;
+}
+/**
+ * The minimum and maximum computed total over all non-excluded
+ * configurations, or null when it cannot be computed (an amount is not
+ * a decimal, a modifier is missing, or every configuration is
+ * excluded). The caller has established that the block resolves to
+ * `configurator`.
+ *
+ * Only the dimensions named in an exclusion or an adjustment are
+ * enumerated together. Every other priced dimension contributes its
+ * smallest modifier to the minimum and its largest to the maximum,
+ * independently of the rest, which yields the same band as the full
+ * enumeration.
+ */
+export function computeBand(configurator, block) {
+    const base = parseDecimal(block["basePrice"]);
+    if (base === undefined)
+        return null;
+    const modifiers = asObject(block["modifiers"]);
+    const adjustments = [];
+    if (Array.isArray(block["adjustments"])) {
+        for (const entry of block["adjustments"]) {
+            const a = asObject(entry);
+            const when = selection(a?.["when"]);
+            const amount = parseDecimal(a?.["priceModifier"]);
+            if (when === null || when.size === 0 || amount === undefined)
+                return null;
+            adjustments.push({ when, amount });
+        }
+    }
+    const coupledNames = new Set();
+    for (const pairs of configurator.exclusions)
+        for (const name of pairs.keys())
+            coupledNames.add(name);
+    for (const { when } of adjustments)
+        for (const name of when.keys())
+            coupledNames.add(name);
+    const modifierOf = (d, option) => parseDecimal(own(asObject(own(modifiers, d.name)), option));
+    let min = base;
+    let max = base;
+    const coupled = [];
+    const seen = new Set();
+    for (const d of configurator.dimensions) {
+        if (seen.has(d.name))
+            continue;
+        seen.add(d.name);
+        if (d.optionKeys === null) {
+            if (d.priced)
+                return null;
+            continue;
+        }
+        if (coupledNames.has(d.name)) {
+            coupled.push(d);
+            continue;
+        }
+        if (!d.priced)
+            continue;
+        let lowest;
+        let highest;
+        for (const option of d.optionKeys) {
+            const amount = modifierOf(d, option);
+            if (amount === undefined)
+                return null;
+            if (lowest === undefined || compareDecimal(amount, lowest) < 0)
+                lowest = amount;
+            if (highest === undefined || compareDecimal(amount, highest) > 0)
+                highest = amount;
+        }
+        if (lowest === undefined || highest === undefined)
+            return null;
+        min = addDecimal(min, lowest);
+        max = addDecimal(max, highest);
+    }
+    let coupledMin;
+    let coupledMax;
+    let incomputable = false;
+    const configuration = new Map();
+    const visit = (index, subtotal) => {
+        if (incomputable)
+            return;
+        if (index === coupled.length) {
+            if (configurator.exclusions.some((pairs) => matches(pairs, configuration)))
+                return;
+            let total = subtotal;
+            for (const { when, amount } of adjustments) {
+                if (matches(when, configuration))
+                    total = addDecimal(total, amount);
+            }
+            if (coupledMin === undefined || compareDecimal(total, coupledMin) < 0)
+                coupledMin = total;
+            if (coupledMax === undefined || compareDecimal(total, coupledMax) > 0)
+                coupledMax = total;
+            return;
+        }
+        const d = coupled[index];
+        for (const option of d.optionKeys ?? []) {
+            let next = subtotal;
+            if (d.priced) {
+                const amount = modifierOf(d, option);
+                if (amount === undefined) {
+                    incomputable = true;
+                    return;
+                }
+                next = addDecimal(subtotal, amount);
+            }
+            configuration.set(d.name, option);
+            visit(index + 1, next);
+        }
+        configuration.delete(d.name);
+    };
+    visit(0, { units: 0n, scale: 0 });
+    if (incomputable || coupledMin === undefined || coupledMax === undefined)
+        return null;
+    return { min: addDecimal(min, coupledMin), max: addDecimal(max, coupledMax) };
+}

package/dist/rules/pdp-e-001.js

@@ -1,4 +1,5 @@
 import { collectDeclaredIds, isInlineDeclaration, isSameDocumentId, valueAtPath, } from "@pagefront/lint-core";
+import { readConfigurator } from "./configurator-pricing.js";
 /**
  * PDP-E-001 — Broken @id reference.
  * Transcribed from commerce/spec/rules.md (normative).
@@ -14,7 +15,12 @@ import { collectDeclaredIds, isInlineDeclaration, isSameDocumentId, valueAtPath,
  * a same-document `@id` (Definitions) must resolve by exact string
  * match; only a non-same-document full URL is a cross-Sheet reference,
  * exempt from internal resolution.
+ *
+ * A pricing block's `configurator` reference has no cross-Sheet
+ * carve-out: whatever its form, it resolves only against the `@id` of
+ * the data block's `pagefront:configurator`, by exact string match.
  */
+const CONFIGURATOR_REFERENCE = /\['pagefront:configuratorPricing'\]\['configurator'\]\['@id'\]$/;
 const REFERENCE_SEGMENT = /\['itemOffered'\]|\['isVariantOf'\]/;
 export const pdpE001 = {
     id: "PDP-E-001",
@@ -22,11 +28,14 @@ export const pdpE001 = {
     severity: "error",
     target: "$..['@id']",
     check: (match, ctx) => {
-        if (!REFERENCE_SEGMENT.test(match.path))
-            return null;
         const value = match.value;
         if (typeof value !== "string")
             return null;
+        if (CONFIGURATOR_REFERENCE.test(match.path)) {
+            return readConfigurator(ctx.sheet)?.id === value ? null : { values: { value } };
+        }
+        if (!REFERENCE_SEGMENT.test(match.path))
+            return null;
         const carrier = valueAtPath(ctx.sheet, match.path.replace(/\['@id'\]$/, ""));
         if (isInlineDeclaration(carrier))
             return null; // declares, not references
@@ -36,7 +45,7 @@ export const pdpE001 = {
         return resolves ? null : { values: { value } };
     },
     messageTemplate: "Reference `{value}` at `{path}` does not resolve to any entity in this Sheet.",
-    remediation: "Either correct the reference to match an existing `@id`, or add the referenced entity to the Sheet. Same-document references (fragments, bare tokens, or full URLs on this Sheet's own base) must resolve within the Sheet, by exact string match. A full-URL `@id` on another document's base in `isVariantOf` or a `hasVariant` entry is a legitimate cross-Sheet reference (multi-Sheet variant family) and is validated for URL shape only — see PDP-W-021 for the traversal-hint recommendation that accompanies it.",
+    remediation: "Either correct the reference to match an existing `@id`, or add the referenced entity to the Sheet. Same-document references (fragments, bare tokens, or full URLs on this Sheet's own base) must resolve within the Sheet, by exact string match. A pricing block's `configurator.@id` must equal the `@id` declared on the Sheet's `pagefront:configurator`. A full-URL `@id` on another document's base in `isVariantOf` or a `hasVariant` entry is a legitimate cross-Sheet reference (multi-Sheet variant family) and is validated for URL shape only — see PDP-W-021 for the traversal-hint recommendation that accompanies it.",
     introduced: "v0.6",
     specReference: "product.md#itemoffered-references",
 };

package/dist/rules/pdp-e-007.d.ts

@@ -0,0 +1,12 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-E-007 — Base configuration incomplete.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Applies to a pricing block whose `configurator` reference resolves.
+ * One finding per omitted priced dimension (in dimension order), then
+ * one per `baseConfiguration` pair naming no dimension or a value that
+ * is not one of the dimension's options (in document order), all at the
+ * `baseConfiguration` path.
+ */
+export declare const pdpE007: Rule;

package/dist/rules/pdp-e-007.js

@@ -0,0 +1,53 @@
+import { asObject, baseConfigurationProblems, resolveConfigurator } from "./configurator-pricing.js";
+/**
+ * PDP-E-007 — Base configuration incomplete.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Applies to a pricing block whose `configurator` reference resolves.
+ * One finding per omitted priced dimension (in dimension order), then
+ * one per `baseConfiguration` pair naming no dimension or a value that
+ * is not one of the dimension's options (in document order), all at the
+ * `baseConfiguration` path.
+ */
+export const pdpE007 = {
+    id: "PDP-E-007",
+    title: "Base configuration incomplete",
+    severity: "error",
+    target: "$.data.offers[*]['pagefront:configuratorPricing']",
+    check: (match, ctx) => {
+        const block = asObject(match.value);
+        if (block === null)
+            return null;
+        const configurator = resolveConfigurator(block, ctx.sheet);
+        if (configurator === null)
+            return null;
+        const path = `${match.path}['baseConfiguration']`;
+        const hits = baseConfigurationProblems(configurator, block).map((p) => {
+            if (p.kind === "omitted") {
+                return { path, values: { dimension: p.dimension, problem: `omits priced dimension \`${p.dimension}\`` } };
+            }
+            if (p.kind === "unknown-dimension") {
+                return {
+                    path,
+                    values: {
+                        dimension: p.dimension,
+                        problem: `names \`${p.dimension}\`, which is not a dimension of the configurator`,
+                    },
+                };
+            }
+            return {
+                path,
+                values: {
+                    dimension: p.dimension,
+                    value: p.value,
+                    problem: `names \`${p.value}\` for \`${p.dimension}\`, which is not one of its options`,
+                },
+            };
+        });
+        return hits.length > 0 ? hits : null;
+    },
+    messageTemplate: "Base configuration at `{path}` {problem}.",
+    remediation: "Name exactly one option for every priced dimension, spelled as the configurator's `options` spell it. If a dimension never changes the price, declare `affectsPrice: false` on it and leave it out.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-e-008.d.ts

@@ -0,0 +1,10 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-E-008 — Base option modifier is not zero.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * One finding per `baseConfiguration` pair whose modifier is present and
+ * differs from zero as a number, at the modifier's own path. A base
+ * option with no modifier is PDP-W-032's concern.
+ */
+export declare const pdpE008: Rule;

package/dist/rules/pdp-e-008.js

@@ -0,0 +1,41 @@
+import { asObject, isZero, optionKey, own, parseDecimal, seg } from "./configurator-pricing.js";
+/**
+ * PDP-E-008 — Base option modifier is not zero.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * One finding per `baseConfiguration` pair whose modifier is present and
+ * differs from zero as a number, at the modifier's own path. A base
+ * option with no modifier is PDP-W-032's concern.
+ */
+export const pdpE008 = {
+    id: "PDP-E-008",
+    title: "Base option modifier is not zero",
+    severity: "error",
+    target: "$.data.offers[*]['pagefront:configuratorPricing']",
+    check: (match) => {
+        const block = asObject(match.value);
+        const base = asObject(block?.["baseConfiguration"]);
+        const modifiers = asObject(block?.["modifiers"]);
+        if (base === null || modifiers === null)
+            return null;
+        const hits = [];
+        for (const [dimension, raw] of Object.entries(base)) {
+            const option = optionKey(raw);
+            if (option === undefined)
+                continue;
+            const stated = own(asObject(own(modifiers, dimension)), option);
+            const modifier = parseDecimal(stated);
+            if (modifier === undefined || isZero(modifier))
+                continue;
+            hits.push({
+                path: `${match.path}['modifiers']${seg(dimension)}${seg(option)}`,
+                values: { dimension, option, modifier: String(stated) },
+            });
+        }
+        return hits.length > 0 ? hits : null;
+    },
+    messageTemplate: "Modifier for base option `{option}` of `{dimension}` at `{path}` is `{modifier}`; the base option's modifier is `0`.",
+    remediation: "Set the base option's modifier to `\"0\"` and express the other options of the dimension as differences from it. If the modifier is right, `basePrice` is the total of another configuration: correct `baseConfiguration` or `basePrice`.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-e-009.d.ts

@@ -0,0 +1,12 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-E-009 — Modifier for an unknown dimension or option.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Applies to a pricing block whose `configurator` reference resolves.
+ * A `modifiers` key naming no dimension, or a dimension declared
+ * `affectsPrice: false`, fires once at that key; under a priced
+ * dimension, each option key that is not one of its options fires at
+ * its own path.
+ */
+export declare const pdpE009: Rule;

package/dist/rules/pdp-e-009.js

@@ -0,0 +1,62 @@
+import { asObject, resolveConfigurator, seg } from "./configurator-pricing.js";
+/**
+ * PDP-E-009 — Modifier for an unknown dimension or option.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Applies to a pricing block whose `configurator` reference resolves.
+ * A `modifiers` key naming no dimension, or a dimension declared
+ * `affectsPrice: false`, fires once at that key; under a priced
+ * dimension, each option key that is not one of its options fires at
+ * its own path.
+ */
+export const pdpE009 = {
+    id: "PDP-E-009",
+    title: "Modifier for an unknown dimension or option",
+    severity: "error",
+    target: "$.data.offers[*]['pagefront:configuratorPricing']",
+    check: (match, ctx) => {
+        const block = asObject(match.value);
+        const modifiers = asObject(block?.["modifiers"]);
+        if (block === null || modifiers === null)
+            return null;
+        const configurator = resolveConfigurator(block, ctx.sheet);
+        if (configurator === null)
+            return null;
+        const hits = [];
+        for (const [dimension, entry] of Object.entries(modifiers)) {
+            const path = `${match.path}['modifiers']${seg(dimension)}`;
+            const d = configurator.byName.get(dimension);
+            if (d === undefined) {
+                hits.push({
+                    path,
+                    values: { dimension, problem: `names \`${dimension}\`, which is not a dimension of the configurator` },
+                });
+                continue;
+            }
+            if (!d.priced) {
+                hits.push({
+                    path,
+                    values: { dimension, problem: `names \`${dimension}\`, which is declared \`affectsPrice: false\`` },
+                });
+                continue;
+            }
+            for (const option of Object.keys(asObject(entry) ?? {})) {
+                if (d.optionKeys !== null && d.optionKeys.includes(option))
+                    continue;
+                hits.push({
+                    path: `${path}${seg(option)}`,
+                    values: {
+                        dimension,
+                        option,
+                        problem: `names \`${option}\`, which is not an option of \`${dimension}\``,
+                    },
+                });
+            }
+        }
+        return hits.length > 0 ? hits : null;
+    },
+    messageTemplate: "Modifier at `{path}` {problem}.",
+    remediation: "Spell dimension names and option values as the configurator spells them. Remove modifiers for dimensions that do not change the price, or remove `affectsPrice: false` from a dimension that does.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-e-010.d.ts

@@ -0,0 +1,10 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-E-010 — Offer price disagrees with base price.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * An `Offer` carrying a pricing block has `price` equal to the block's
+ * `basePrice` as a number, whatever the block's `pricing` value. The
+ * finding sits at the Offer's `price`.
+ */
+export declare const pdpE010: Rule;

package/dist/rules/pdp-e-010.js

@@ -0,0 +1,37 @@
+import { asObject, compareDecimal, parseDecimal, pricingBlock } from "./configurator-pricing.js";
+/**
+ * PDP-E-010 — Offer price disagrees with base price.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * An `Offer` carrying a pricing block has `price` equal to the block's
+ * `basePrice` as a number, whatever the block's `pricing` value. The
+ * finding sits at the Offer's `price`.
+ */
+export const pdpE010 = {
+    id: "PDP-E-010",
+    title: "Offer price disagrees with base price",
+    severity: "error",
+    target: "$.data.offers[*]",
+    check: (match) => {
+        const offer = asObject(match.value);
+        if (offer === null || offer["@type"] !== "Offer")
+            return null;
+        const block = pricingBlock(offer);
+        if (block === null)
+            return null;
+        const price = parseDecimal(offer["price"]);
+        const basePrice = parseDecimal(block["basePrice"]);
+        if (price === undefined || basePrice === undefined)
+            return null;
+        if (compareDecimal(price, basePrice) === 0)
+            return null;
+        return {
+            path: `${match.path}['price']`,
+            values: { price: String(offer["price"]), basePrice: String(block["basePrice"]) },
+        };
+    },
+    messageTemplate: "Offer `price` at `{path}` is `{price}` but its pricing block's `basePrice` is `{basePrice}`.",
+    remediation: "Make the two amounts equal. If `price` is the amount the page shows on load, set `baseConfiguration` to the configuration the page preselects and `basePrice` to its total.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-e-011.d.ts

@@ -0,0 +1,11 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-E-011 — AggregateOffer band disagrees with computed band.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Applies to an `AggregateOffer` whose pricing block is complete. Silent
+ * when the band cannot be computed: the reference does not resolve, the
+ * block fires PDP-E-007 or PDP-W-032, or every configuration is
+ * excluded. One finding per disagreeing bound, at the bound.
+ */
+export declare const pdpE011: Rule;