@pagefront/lint-commerce 0.7.0 → 0.9.0

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;

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

@@ -0,0 +1,53 @@
+import { asObject, baseConfigurationProblems, compareDecimal, computeBand, formatDecimal, isComplete, missingModifierProblems, parseDecimal, pricingBlock, resolveConfigurator, } from "./configurator-pricing.js";
+/**
+ * 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 const pdpE011 = {
+    id: "PDP-E-011",
+    title: "AggregateOffer band disagrees with computed band",
+    severity: "error",
+    target: "$.data.offers[*]",
+    check: (match, ctx) => {
+        const offer = asObject(match.value);
+        if (offer === null || offer["@type"] !== "AggregateOffer")
+            return null;
+        const block = pricingBlock(offer);
+        if (block === null || !isComplete(block))
+            return null;
+        const configurator = resolveConfigurator(block, ctx.sheet);
+        if (configurator === null)
+            return null;
+        if (baseConfigurationProblems(configurator, block).length > 0)
+            return null;
+        if (missingModifierProblems(configurator, block).length > 0)
+            return null;
+        const band = computeBand(configurator, block);
+        if (band === null)
+            return null;
+        const hits = [];
+        const bounds = [
+            { bound: "lowPrice", extreme: "cheapest", computed: band.min },
+            { bound: "highPrice", extreme: "dearest", computed: band.max },
+        ];
+        for (const { bound, extreme, computed } of bounds) {
+            const stated = parseDecimal(offer[bound]);
+            if (stated === undefined || compareDecimal(stated, computed) === 0)
+                continue;
+            hits.push({
+                path: `${match.path}['${bound}']`,
+                values: { bound, extreme, stated: String(offer[bound]), computed: formatDecimal(computed) },
+            });
+        }
+        return hits.length > 0 ? hits : null;
+    },
+    messageTemplate: "`{bound}` at `{path}` is `{stated}` but the {extreme} non-excluded configuration computed from the pricing block totals `{computed}`.",
+    remediation: "Correct the bound, or correct the price list: a missing adjustment, a missing exclusion and a wrong modifier each move the computed band. If the price list is known to have gaps, declare `pricing: \"partial\"`.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

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

@@ -0,0 +1,2 @@
+import type { Rule } from "@pagefront/lint-core";
+export declare const pdpE012: Rule;

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

@@ -0,0 +1,32 @@
+import { pricedConfiguratorId, pricingBlock } from "./configurator-pricing.js";
+/**
+ * PDP-E-012 — Configurator priced by more than one offer.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires on each `offers` entry whose pricing block names a configurator
+ * that an earlier entry already prices (exact string match on
+ * `configurator.@id`); `{firstPath}` is the first such entry.
+ */
+function pricedId(offer) {
+    const block = pricingBlock(offer);
+    return block === null ? undefined : pricedConfiguratorId(block);
+}
+export const pdpE012 = {
+    id: "PDP-E-012",
+    title: "Configurator priced by more than one offer",
+    severity: "error",
+    target: "$.data.offers[*]",
+    check: (match, ctx) => {
+        const value = pricedId(match.value);
+        if (value === undefined)
+            return null;
+        const first = ctx.allMatches.find((m) => pricedId(m.value) === value);
+        if (first === undefined || first.path === match.path)
+            return null;
+        return { values: { value, firstPath: first.path } };
+    },
+    messageTemplate: "Offer at `{path}` prices configurator `{value}`, which the offer at `{firstPath}` already prices.",
+    remediation: "Keep one pricing block per configurator. Publish each further market's price list in that market's own Sheet.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

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

@@ -0,0 +1,9 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-E-013 — Text dimension with options.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires on a dimension whose `inputType` is `text` and whose `options`
+ * is an array with at least one entry.
+ */
+export declare const pdpE013: Rule;

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

@@ -0,0 +1,26 @@
+import { asObject } from "./configurator-pricing.js";
+/**
+ * PDP-E-013 — Text dimension with options.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires on a dimension whose `inputType` is `text` and whose `options`
+ * is an array with at least one entry.
+ */
+export const pdpE013 = {
+    id: "PDP-E-013",
+    title: "Text dimension with options",
+    severity: "error",
+    target: "$.data['pagefront:configurator'].dimensions[*]",
+    check: (match) => {
+        const d = asObject(match.value);
+        if (d === null || d["inputType"] !== "text")
+            return null;
+        if (!Array.isArray(d["options"]) || d["options"].length === 0)
+            return null;
+        return { values: { dimension: typeof d["name"] === "string" ? d["name"] : "(unnamed)" } };
+    },
+    messageTemplate: "Dimension `{dimension}` at `{path}` declares `inputType: \"text\"` and enumerates options.",
+    remediation: "Remove `options` from a free-text dimension, or remove `inputType: \"text\"` from a dimension the buyer picks a value in.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

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

@@ -0,0 +1,11 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-E-014 — Size advice in another system than the sizing dimension.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires when the adjustment carries a `sizeSystem`, the configurator has
+ * a sizing dimension in `UK`, `EU`, `US` or `JP`, and the adjustment's
+ * system corresponds to none of them. The `https://schema.org/` prefix
+ * on `sizeSystem` is accepted.
+ */
+export declare const pdpE014: Rule;

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

@@ -0,0 +1,34 @@
+import { asObject, CORRESPONDING_SIZE_SYSTEM, readConfigurator } from "./configurator-pricing.js";
+/**
+ * PDP-E-014 — Size advice in another system than the sizing dimension.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires when the adjustment carries a `sizeSystem`, the configurator has
+ * a sizing dimension in `UK`, `EU`, `US` or `JP`, and the adjustment's
+ * system corresponds to none of them. The `https://schema.org/` prefix
+ * on `sizeSystem` is accepted.
+ */
+export const pdpE014 = {
+    id: "PDP-E-014",
+    title: "Size advice in another system than the sizing dimension",
+    severity: "error",
+    target: "$.data['pagefront:sizeRecommendation'].sizeAdjustment",
+    check: (match, ctx) => {
+        const sizeSystem = asObject(match.value)?.["sizeSystem"];
+        if (typeof sizeSystem !== "string")
+            return null;
+        const systems = (readConfigurator(ctx.sheet)?.dimensions ?? [])
+            .map((d) => d.system)
+            .filter((s) => s !== undefined && Object.hasOwn(CORRESPONDING_SIZE_SYSTEM, s));
+        if (systems.length === 0)
+            return null;
+        const bare = sizeSystem.replace(/^https?:\/\/schema\.org\//, "");
+        if (systems.some((s) => CORRESPONDING_SIZE_SYSTEM[s] === bare))
+            return null;
+        return { values: { sizeSystem, dimensionSystem: systems[0] } };
+    },
+    messageTemplate: "Size adjustment at `{path}` is in `{sizeSystem}` but the Sheet's sizing dimension is in `{dimensionSystem}`.",
+    remediation: "State the adjustment in the sizing dimension's system if the merchant states it there. If the merchant's advice is in another system, remove `sizeAdjustment` and keep the merchant's wording in `description`.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#size-guidance-pagefrontsizechart-and-pagefrontsizerecommendation",
+};

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

@@ -0,0 +1,2 @@
+import type { Rule } from "@pagefront/lint-core";
+export declare const pdpE015: Rule;

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

@@ -0,0 +1,91 @@
+import { asObject, seg } from "./configurator-pricing.js";
+/**
+ * PDP-E-015 — Amounts mix numbers and strings.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Walks `data` in document order over the catalogue's closed list of
+ * amount fields and fires once per Sheet when at least one amount is a
+ * JSON number and at least one is a string. `numberPath` and
+ * `stringPath` are the first amount of each carrier.
+ */
+const OFFER_FIELDS = ["price", "lowPrice", "highPrice"];
+const SPECIFICATION_FIELDS = ["price", "minPrice", "maxPrice"];
+const MONETARY_FIELDS = ["value", "minValue", "maxValue"];
+const ROLE_OF_KEY = {
+    offers: "offer",
+    priceSpecification: "specification",
+    hasVariant: "variant",
+    "pagefront:promotions": "promotion",
+    "pagefront:configuratorPricing": "pricing",
+};
+function record(found, value, path) {
+    if (typeof value === "number")
+        found.numberPath ??= path;
+    else if (typeof value === "string")
+        found.stringPath ??= path;
+}
+function amountFields(node, role) {
+    const fields = [];
+    if (role === "offer")
+        fields.push(...OFFER_FIELDS);
+    if (role === "specification")
+        fields.push(...SPECIFICATION_FIELDS);
+    if (role === "variant")
+        fields.push("price");
+    if (role === "promotion")
+        fields.push("discountAmount");
+    if (role === "pricing")
+        fields.push("basePrice");
+    if (role === "adjustment")
+        fields.push("priceModifier");
+    if (node["@type"] === "MonetaryAmount")
+        fields.push(...MONETARY_FIELDS);
+    return fields;
+}
+function walk(node, path, role, found) {
+    if (Array.isArray(node)) {
+        node.forEach((item, index) => walk(item, `${path}[${index}]`, role, found));
+        return;
+    }
+    const obj = asObject(node);
+    if (obj === null)
+        return;
+    const fields = amountFields(obj, role);
+    for (const [key, value] of Object.entries(obj)) {
+        const childPath = `${path}${seg(key)}`;
+        if (fields.includes(key)) {
+            record(found, value, childPath);
+            continue;
+        }
+        if (role === "modifiers") {
+            // one entry per dimension; every value under it is an amount
+            for (const [option, amount] of Object.entries(asObject(value) ?? {})) {
+                record(found, amount, `${childPath}${seg(option)}`);
+            }
+            continue;
+        }
+        let childRole = ROLE_OF_KEY[key];
+        if (role === "pricing" && key === "modifiers")
+            childRole = "modifiers";
+        if (role === "pricing" && key === "adjustments")
+            childRole = "adjustment";
+        walk(value, childPath, childRole, found);
+    }
+}
+export const pdpE015 = {
+    id: "PDP-E-015",
+    title: "Amounts mix numbers and strings",
+    severity: "error",
+    target: "$.data",
+    check: (match) => {
+        const found = {};
+        walk(match.value, match.path, undefined, found);
+        if (found.numberPath === undefined || found.stringPath === undefined)
+            return null;
+        return { values: { numberPath: found.numberPath, stringPath: found.stringPath } };
+    },
+    messageTemplate: "Amounts mix numbers and strings; use one carrier throughout the Sheet.",
+    remediation: "Carry every amount the same way. Decimal strings are recommended when amounts have fractional parts.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#amounts",
+};

package/dist/rules/pdp-w-032.d.ts

@@ -0,0 +1,11 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-032 — Priced option without a modifier.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Applies to a resolving pricing block whose `pricing` is absent or
+ * `complete`. One finding per priced option with no modifier, one per
+ * priced text dimension with no `*` modifier, and one per priced select
+ * dimension that enumerates no options, all at the block.
+ */
+export declare const pdpW032: Rule;

package/dist/rules/pdp-w-032.js

@@ -0,0 +1,50 @@
+import { asObject, isComplete, missingModifierProblems, resolveConfigurator, } from "./configurator-pricing.js";
+/**
+ * PDP-W-032 — Priced option without a modifier.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Applies to a resolving pricing block whose `pricing` is absent or
+ * `complete`. One finding per priced option with no modifier, one per
+ * priced text dimension with no `*` modifier, and one per priced select
+ * dimension that enumerates no options, all at the block.
+ */
+export const pdpW032 = {
+    id: "PDP-W-032",
+    title: "Priced option without a modifier",
+    severity: "warning",
+    target: "$.data.offers[*]['pagefront:configuratorPricing']",
+    check: (match, ctx) => {
+        const block = asObject(match.value);
+        if (block === null || !isComplete(block))
+            return null;
+        const configurator = resolveConfigurator(block, ctx.sheet);
+        if (configurator === null)
+            return null;
+        const hits = missingModifierProblems(configurator, block).map((p) => p.kind === "no-text-modifier"
+            ? {
+                values: {
+                    dimension: p.dimension,
+                    problem: `states no \`*\` modifier for text dimension \`${p.dimension}\``,
+                },
+            }
+            : p.kind === "no-options"
+                ? {
+                    values: {
+                        dimension: p.dimension,
+                        problem: `cannot state modifiers for \`${p.dimension}\`, a priced dimension that enumerates no options`,
+                    },
+                }
+                : {
+                    values: {
+                        dimension: p.dimension,
+                        option: p.option,
+                        problem: `states no modifier for option \`${p.option}\` of \`${p.dimension}\``,
+                    },
+                });
+        return hits.length > 0 ? hits : null;
+    },
+    messageTemplate: "Pricing block at `{path}` {problem}, and `pricing` is not `partial`.",
+    remediation: "State the modifier, zero included; for a text dimension, state it under the key `\"*\"`. If the dimension never changes the price, declare `affectsPrice: false` on it. If the price is not known, declare `pricing: \"partial\"`.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-w-033.d.ts

@@ -0,0 +1,10 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-033 — Priced configurator with no offer pricing it.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires when the configurator has a priced dimension, no `offers` entry
+ * carries a pricing block, and no `offers` entry states a price. The
+ * last case is PDP-W-034's; the two never fire on the same Sheet.
+ */
+export declare const pdpW033: Rule;

package/dist/rules/pdp-w-033.js

@@ -0,0 +1,30 @@
+import { entryStatesPrice, hasPricedDimension, offerEntries, pricingBlock, readConfigurator, } from "./configurator-pricing.js";
+/**
+ * PDP-W-033 — Priced configurator with no offer pricing it.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires when the configurator has a priced dimension, no `offers` entry
+ * carries a pricing block, and no `offers` entry states a price. The
+ * last case is PDP-W-034's; the two never fire on the same Sheet.
+ */
+export const pdpW033 = {
+    id: "PDP-W-033",
+    title: "Priced configurator with no offer pricing it",
+    severity: "warning",
+    target: "$.data['pagefront:configurator']",
+    check: (_match, ctx) => {
+        const configurator = readConfigurator(ctx.sheet);
+        if (configurator === null || !hasPricedDimension(configurator))
+            return null;
+        const offers = offerEntries(ctx.sheet);
+        if (offers.some((o) => pricingBlock(o) !== null))
+            return null;
+        if (offers.some(entryStatesPrice))
+            return null;
+        return {};
+    },
+    messageTemplate: "Configurator at `{path}` has priced dimensions but no offer prices it.",
+    remediation: "Add an offer carrying `pagefront:configuratorPricing` for this configurator. If no option changes the price, declare `affectsPrice: false` on each dimension.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-w-034.d.ts

@@ -0,0 +1,10 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-034 — Offer beside a configurator with no pricing block.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires once per Sheet, at the first `offers` entry that states a
+ * price, when the Sheet carries a configurator with a priced dimension
+ * and no `offers` entry carries a pricing block.
+ */
+export declare const pdpW034: Rule;

package/dist/rules/pdp-w-034.js

@@ -0,0 +1,28 @@
+import { entryStatesPrice, hasPricedDimension, pricingBlock, readConfigurator, } from "./configurator-pricing.js";
+/**
+ * PDP-W-034 — Offer beside a configurator with no pricing block.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires once per Sheet, at the first `offers` entry that states a
+ * price, when the Sheet carries a configurator with a priced dimension
+ * and no `offers` entry carries a pricing block.
+ */
+export const pdpW034 = {
+    id: "PDP-W-034",
+    title: "Offer beside a configurator with no pricing block",
+    severity: "warning",
+    target: "$.data.offers[*]",
+    check: (match, ctx) => {
+        const configurator = readConfigurator(ctx.sheet);
+        if (configurator === null || !hasPricedDimension(configurator))
+            return null;
+        if (ctx.allMatches.some((m) => pricingBlock(m.value) !== null))
+            return null;
+        const first = ctx.allMatches.find((m) => entryStatesPrice(m.value));
+        return first !== undefined && first.path === match.path ? {} : null;
+    },
+    messageTemplate: "Offer price is not linked to the configurator; state which configuration it prices.",
+    remediation: "Add `pagefront:configuratorPricing` to the offer: give the configurator an `@id`, reference it, and name the configuration the price is the total of. When only that one total is known, declare `pricing: \"partial\"`.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-w-035.d.ts

@@ -0,0 +1,11 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-035 — `basePrice` may be a component price.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Heuristic, one finding per pricing block: (a) `basePrice` equals the
+ * largest modifier of one dimension's `modifiers` entry, or (b)
+ * `basePrice` is below every non-zero modifier of one entry that has at
+ * least one.
+ */
+export declare const pdpW035: Rule;

package/dist/rules/pdp-w-035.js

@@ -0,0 +1,41 @@
+import { asObject, compareDecimal, isZero, parseDecimal, } from "./configurator-pricing.js";
+/**
+ * PDP-W-035 — `basePrice` may be a component price.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Heuristic, one finding per pricing block: (a) `basePrice` equals the
+ * largest modifier of one dimension's `modifiers` entry, or (b)
+ * `basePrice` is below every non-zero modifier of one entry that has at
+ * least one.
+ */
+export const pdpW035 = {
+    id: "PDP-W-035",
+    title: "`basePrice` may be a component price",
+    severity: "warning",
+    target: "$.data.offers[*]['pagefront:configuratorPricing']",
+    check: (match) => {
+        const block = asObject(match.value);
+        const modifiers = asObject(block?.["modifiers"]);
+        const basePrice = parseDecimal(block?.["basePrice"]);
+        if (modifiers === null || basePrice === undefined)
+            return null;
+        for (const entry of Object.values(modifiers)) {
+            const amounts = Object.values(asObject(entry) ?? {})
+                .map(parseDecimal)
+                .filter((d) => d !== undefined);
+            if (amounts.length === 0)
+                continue;
+            const largest = amounts.reduce((a, b) => (compareDecimal(b, a) > 0 ? b : a));
+            if (compareDecimal(basePrice, largest) === 0)
+                return {};
+            const nonZero = amounts.filter((d) => !isZero(d));
+            if (nonZero.length > 0 && nonZero.every((d) => compareDecimal(basePrice, d) < 0))
+                return {};
+        }
+        return null;
+    },
+    messageTemplate: "basePrice may be a component price, not a configured total.",
+    remediation: "Confirm that `basePrice` is what a buyer pays for the whole of `baseConfiguration`. If it is the price of one part, replace it with the configured total and recompute the modifiers as differences from that total.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-w-036.d.ts

@@ -0,0 +1,2 @@
+import { type Rule } from "@pagefront/lint-core";
+export declare const pdpW036: Rule;

package/dist/rules/pdp-w-036.js

@@ -0,0 +1,31 @@
+import { valueAtPath } from "@pagefront/lint-core";
+import { asObject } from "./configurator-pricing.js";
+/**
+ * PDP-W-036 — Option value looks like a display label.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Heuristic on string option values: whitespace, an uppercase letter,
+ * or a decimal number followed by letters to the end (a unit suffix).
+ * Options of a sizing dimension (one declaring `system`) are exempt;
+ * PDP-W-037 checks those.
+ */
+const UNIT_SUFFIX = /^-?\d+(\.\d+)?\p{L}+$/u;
+export const pdpW036 = {
+    id: "PDP-W-036",
+    title: "Option value looks like a display label",
+    severity: "warning",
+    target: "$.data['pagefront:configurator'].dimensions[*].options[*]",
+    check: (match, ctx) => {
+        const value = asObject(match.value)?.["value"];
+        if (typeof value !== "string")
+            return null;
+        const dimension = asObject(valueAtPath(ctx.sheet, match.path.replace(/\['options'\]\[\d+\]$/, "")));
+        if (typeof dimension?.["system"] === "string")
+            return null;
+        return /\s/.test(value) || /\p{Lu}/u.test(value) || UNIT_SUFFIX.test(value) ? {} : null;
+    },
+    messageTemplate: "Option value should be a stable identifier; put the label in description.",
+    remediation: "Replace the value with a lowercase identifier without spaces (`yellow_gold`, `0.5`) and move the label to `description`. Put a unit in the dimension's `note`. Update the pricing block's keys, `baseConfiguration`, `when` and `exclusions` to the new value.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-w-037.d.ts

@@ -0,0 +1,2 @@
+import { type Rule } from "@pagefront/lint-core";
+export declare const pdpW037: Rule;

package/dist/rules/pdp-w-037.js

@@ -0,0 +1,37 @@
+import { valueAtPath } from "@pagefront/lint-core";
+import { asObject } from "./configurator-pricing.js";
+/**
+ * PDP-W-037 — Option in a sizing dimension is not a size.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Heuristic on string option values of a dimension whose `system` is
+ * `UK`, `EU`, `US` or `JP`: the value is written as that system writes
+ * a size. Other systems are out of scope.
+ */
+const NUMERIC_SIZE = /^\d+(\.\d+|½)?$/;
+const SIZE_IN_SYSTEM = {
+    UK: /^[A-Z]\s*½?$/,
+    EU: NUMERIC_SIZE,
+    US: NUMERIC_SIZE,
+    JP: NUMERIC_SIZE,
+};
+export const pdpW037 = {
+    id: "PDP-W-037",
+    title: "Option in a sizing dimension is not a size",
+    severity: "warning",
+    target: "$.data['pagefront:configurator'].dimensions[*].options[*]",
+    check: (match, ctx) => {
+        const value = asObject(match.value)?.["value"];
+        if (typeof value !== "string")
+            return null;
+        const dimension = asObject(valueAtPath(ctx.sheet, match.path.replace(/\['options'\]\[\d+\]$/, "")));
+        const system = dimension?.["system"];
+        if (typeof system !== "string" || !Object.hasOwn(SIZE_IN_SYSTEM, system))
+            return null;
+        return SIZE_IN_SYSTEM[system].test(value) ? null : {};
+    },
+    messageTemplate: "Option does not look like a size in the declared system.",
+    remediation: "Remove the entry if it is a service, and describe the service in the dimension's `note` or in `pagefront:madeToOrderTerms.aftermarketServices`. If it is a size, write it as the system writes it, without the system's name.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-w-038.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "@pagefront/lint-core";
+export declare const pdpW038: Rule;

package/dist/rules/pdp-w-038.js

@@ -0,0 +1,30 @@
+import { asObject } from "./configurator-pricing.js";
+/**
+ * PDP-W-038 — Configurator note reads as page copy.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Heuristic on English Sheets (`inLanguage` `en` or `en-…`): the
+ * dimension's `note` contains `you`, `your`, `select`, `order` or
+ * `contact` as a whole word, delimited by non-letters.
+ */
+const PAGE_COPY_WORD = /(?<!\p{L})(you|your|select|order|contact)(?!\p{L})/iu;
+export const pdpW038 = {
+    id: "PDP-W-038",
+    title: "Configurator note reads as page copy",
+    severity: "warning",
+    target: "$.data['pagefront:configurator'].dimensions[*]",
+    check: (match, ctx) => {
+        const inLanguage = asObject(ctx.sheet.data)?.["inLanguage"];
+        if (typeof inLanguage !== "string" || !/^en(-|$)/i.test(inLanguage))
+            return null;
+        const note = asObject(match.value)?.["note"];
+        if (typeof note !== "string")
+            return null;
+        const found = PAGE_COPY_WORD.exec(note);
+        return found === null ? null : { values: { word: found[1].toLowerCase() } };
+    },
+    messageTemplate: "Note reads as page copy; state the fact.",
+    remediation: "Restate the note as a fact in the third person: what the merchant offers or recommends, with no \"you\" and no instruction.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-w-039.d.ts

@@ -0,0 +1,10 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-039 — Size advice carried as prose only.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires when `pagefront:sizeRecommendation` carries a non-empty
+ * `description` and no `sizeAdjustment`, and the configurator has a
+ * sizing dimension. `{system}` is the first sizing dimension's system.
+ */
+export declare const pdpW039: Rule;

package/dist/rules/pdp-w-039.js

@@ -0,0 +1,29 @@
+import { asObject, readConfigurator } from "./configurator-pricing.js";
+/**
+ * PDP-W-039 — Size advice carried as prose only.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires when `pagefront:sizeRecommendation` carries a non-empty
+ * `description` and no `sizeAdjustment`, and the configurator has a
+ * sizing dimension. `{system}` is the first sizing dimension's system.
+ */
+export const pdpW039 = {
+    id: "PDP-W-039",
+    title: "Size advice carried as prose only",
+    severity: "warning",
+    target: "$.data['pagefront:sizeRecommendation']",
+    check: (match, ctx) => {
+        const recommendation = asObject(match.value);
+        if (recommendation === null || recommendation["sizeAdjustment"] !== undefined)
+            return null;
+        const description = recommendation["description"];
+        if (typeof description !== "string" || description.trim() === "")
+            return null;
+        const sizing = (readConfigurator(ctx.sheet)?.dimensions ?? []).find((d) => d.system !== undefined);
+        return sizing?.system === undefined ? null : { values: { system: sizing.system } };
+    },
+    messageTemplate: "Size advice at `{path}` could not be stated in the Sheet's sizing system (`{system}`); it is carried as prose only.",
+    remediation: "If the merchant states the advice in the sizing dimension's system, add a `sizeAdjustment` in that system. If it does not, no action: do not convert between systems.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#size-guidance-pagefrontsizechart-and-pagefrontsizerecommendation",
+};