@pagefront/lint-commerce 0.1.0

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

@@ -0,0 +1,33 @@
+/**
+ * PDP-W-015 — Price-on-request without contact channel.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Bespoke check: `method` is anything other than `unspecified` and none
+ * of `contactUrl`, `contactEmail`, `contactPhone` is declared (key
+ * presence — the catalogue's "declares none of").
+ */
+export const pdpW015 = {
+    id: "PDP-W-015",
+    title: "Price-on-request without contact channel",
+    severity: "warning",
+    target: "$.data.offers[*]['pagefront:priceOnRequest']",
+    check: (match) => {
+        const block = match.value;
+        if (typeof block !== "object" || block === null)
+            return null;
+        const b = block;
+        const method = b["method"];
+        if (typeof method !== "string" || method === "unspecified")
+            return null;
+        if (b["contactUrl"] !== undefined ||
+            b["contactEmail"] !== undefined ||
+            b["contactPhone"] !== undefined) {
+            return null;
+        }
+        return { values: { method } };
+    },
+    messageTemplate: "Price-on-request at `{path}` declares method `{method}` but no contact channel (`contactUrl`, `contactEmail`, or `contactPhone`).",
+    remediation: "Add the contact channel matching the declared method (e.g., `contactUrl` for `authorized_retailer` and `dealer_network`, `contactEmail` for `email`, `contactPhone` for `phone`, `contactUrl` for `quote_form`). If no such channel exists, change `method` to `unspecified`.",
+    introduced: "v0.6",
+    specReference: "product.md#price-on-request-offers",
+};

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

@@ -0,0 +1,9 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-016 — Possibly-missed price.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Bespoke cross-field check: `availability` and `priceCurrency` present,
+ * but no `price`, no `priceSpecification`, no `pagefront:priceOnRequest`.
+ */
+export declare const pdpW016: Rule;

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

@@ -0,0 +1,30 @@
+/**
+ * PDP-W-016 — Possibly-missed price.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Bespoke cross-field check: `availability` and `priceCurrency` present,
+ * but no `price`, no `priceSpecification`, no `pagefront:priceOnRequest`.
+ */
+export const pdpW016 = {
+    id: "PDP-W-016",
+    title: "Possibly-missed price",
+    severity: "warning",
+    target: "$.data.offers[*]",
+    check: (match) => {
+        const offer = match.value;
+        if (typeof offer !== "object" || offer === null)
+            return null;
+        const o = offer;
+        return o["availability"] !== undefined &&
+            o["priceCurrency"] !== undefined &&
+            o["price"] === undefined &&
+            o["priceSpecification"] === undefined &&
+            o["pagefront:priceOnRequest"] === undefined
+            ? {}
+            : null;
+    },
+    messageTemplate: "Offer at `{path}` has commercial structure (availability, priceCurrency) but no price declaration (no `price`, no `priceSpecification`, no `pagefront:priceOnRequest`).",
+    remediation: "Add `price` (and confirm `priceCurrency`) if the price was missed during extraction. If the merchant intentionally publishes no price, declare `pagefront:priceOnRequest` with an appropriate `method` and contact channel.",
+    introduced: "v0.6",
+    specReference: "product.md#price-on-request-offers",
+};

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

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

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

@@ -0,0 +1,55 @@
+/**
+ * PDP-W-017 — Non-canonical BCP 47 language tag.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * The catalogue's target — "`$.data.inLanguage` and any other
+ * `inLanguage` fields in the Sheet" — is expressed as `$..inLanguage`,
+ * which matches every `inLanguage` field at any depth.
+ *
+ * Canonical case per RFC 5646 §2.1.1: language subtag lowercase,
+ * two-letter region subtags uppercase, four-letter (script) subtags
+ * title-case — but only before the first singleton (a single-character
+ * subtag: an extension singleton like `u`/`t`, or private-use `x`).
+ * Every subtag from the first singleton onward, inclusive, is
+ * lowercase. Case conventions only: no IANA-registry canonicalization
+ * (preferred-value substitution, extlang reduction). Only string
+ * values are checked; non-string values are Layer 1's concern.
+ */
+function canonicalCase(tag) {
+    let afterSingleton = false;
+    return tag
+        .split("-")
+        .map((subtag, index) => {
+        const lower = subtag.toLowerCase();
+        if (subtag.length === 1)
+            afterSingleton = true;
+        if (index === 0 || afterSingleton)
+            return lower;
+        if (subtag.length === 2 && /^[a-z]{2}$/i.test(subtag)) {
+            return lower.toUpperCase();
+        }
+        if (subtag.length === 4 && /^[a-z]{4}$/i.test(subtag)) {
+            return lower[0].toUpperCase() + lower.slice(1);
+        }
+        return lower;
+    })
+        .join("-");
+}
+export const pdpW017 = {
+    id: "PDP-W-017",
+    title: "Non-canonical BCP 47 language tag",
+    severity: "warning",
+    target: "$..inLanguage",
+    check: (match) => {
+        if (typeof match.value !== "string")
+            return null;
+        const canonical = canonicalCase(match.value);
+        return canonical === match.value
+            ? null
+            : { values: { value: match.value, canonical } };
+    },
+    messageTemplate: 'Language tag at `{path}` uses non-canonical case: `"{value}"`. Canonical form is `"{canonical}"`.',
+    remediation: "Normalize the tag to canonical BCP 47 case. The semantic meaning is unchanged; only the case differs.",
+    introduced: "v0.6",
+    specReference: "product.md#upstream-equivalent-forms",
+};

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

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

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

@@ -0,0 +1,32 @@
+/**
+ * PDP-W-018 — Inconsistent per-variant URL presence.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires on each url-less entry when at least one sibling declares a
+ * non-empty `url` — the sibling comparison runs over ctx.allMatches
+ * (every `hasVariant` entry). The catalogue's "`@type` is `ProductGroup`
+ * (or `data.hasVariant` is present)" gate is satisfied by the target
+ * itself: `$.data.hasVariant[*]` only matches when `hasVariant` is
+ * present.
+ */
+const hasUrl = (value) => typeof value === "object" &&
+    value !== null &&
+    typeof value["url"] === "string" &&
+    value["url"].trim() !== "";
+export const pdpW018 = {
+    id: "PDP-W-018",
+    title: "Inconsistent per-variant URL presence",
+    severity: "warning",
+    target: "$.data.hasVariant[*]",
+    check: (match, ctx) => {
+        if (ctx.allMatches.length < 2)
+            return null;
+        if (hasUrl(match.value))
+            return null;
+        return ctx.allMatches.some((m) => hasUrl(m.value)) ? {} : null;
+    },
+    messageTemplate: "Variant at `{path}` has no `url`, but other variants in the same ProductGroup declare one.",
+    remediation: "Add a `url` to this variant matching its distinct addressable page state, consistent with its siblings. If this variant genuinely shares the exact same URL as the others with no parameter-based differentiation (case 1 in the spec), the per-variant `url` should instead be omitted from *all* entries so presence is uniform.",
+    introduced: "v0.7",
+    specReference: "product.md#per-variant-urls",
+};

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

@@ -0,0 +1,14 @@
+import { type Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-019 — relatedProduct identifier present but unusable.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires when every present value among `sku`, `gtin`, `gtin13`, `mpn`
+ * is empty or whitespace-only, and any present `@id` is empty,
+ * whitespace-only, or not URL-shaped (a full absolute URL per the
+ * Definitions section). An entry with no identifier key at all fails
+ * Layer 1's `anyOf` and never reaches the linter; defensively, such an
+ * entry does not fire here. `{name}` is the entry's `name`, or the
+ * literal `(unnamed)` when absent — the schema does not require `name`.
+ */
+export declare const pdpW019: Rule;

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

@@ -0,0 +1,49 @@
+import { isFullAbsoluteUrl } from "@pagefront/lint-core";
+/**
+ * PDP-W-019 — relatedProduct identifier present but unusable.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires when every present value among `sku`, `gtin`, `gtin13`, `mpn`
+ * is empty or whitespace-only, and any present `@id` is empty,
+ * whitespace-only, or not URL-shaped (a full absolute URL per the
+ * Definitions section). An entry with no identifier key at all fails
+ * Layer 1's `anyOf` and never reaches the linter; defensively, such an
+ * entry does not fire here. `{name}` is the entry's `name`, or the
+ * literal `(unnamed)` when absent — the schema does not require `name`.
+ */
+export const pdpW019 = {
+    id: "PDP-W-019",
+    title: "relatedProduct identifier present but unusable",
+    severity: "warning",
+    target: "$.data['pagefront:relatedProduct'][*]",
+    check: (match) => {
+        const entry = match.value;
+        if (typeof entry !== "object" || entry === null)
+            return null;
+        const e = entry;
+        let anyPresent = false;
+        let anyUsable = false;
+        for (const key of ["sku", "gtin", "gtin13", "mpn"]) {
+            if (e[key] === undefined)
+                continue;
+            anyPresent = true;
+            if (typeof e[key] === "string" && e[key].trim() !== "") {
+                anyUsable = true;
+            }
+        }
+        if (e["@id"] !== undefined) {
+            anyPresent = true;
+            if (isFullAbsoluteUrl(e["@id"]) && e["@id"].trim() !== "") {
+                anyUsable = true;
+            }
+        }
+        if (!anyPresent || anyUsable)
+            return null;
+        const name = typeof e["name"] === "string" ? e["name"] : "(unnamed)";
+        return { values: { name } };
+    },
+    messageTemplate: "`pagefront:relatedProduct` entry `{name}` at `{path}` carries an identifier field that is present but empty or non-dereferenceable, so it has no usable structured identifier.",
+    remediation: "Supply a real, dereferenceable identifier — a URL-shaped `@id`, or a non-empty `sku`, `gtin`, `gtin13`, or `mpn`. If no structured identifier is available for this reference, it does not meet `pagefront:relatedProduct`'s requirement: move it to Schema.org's native `isRelatedTo` (which carries no identifier requirement) and drop the `relationship` typing.",
+    introduced: "v0.7",
+    specReference: "product.md#the-structured-identifier-requirement",
+};

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

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

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

@@ -0,0 +1,64 @@
+import { collectDeclaredIds, isInlineDeclaration, isSameDocumentId, } from "@pagefront/lint-core";
+/**
+ * PDP-W-020 — Relationship reference lacks any identifying field.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * The target selects the five relationship-field values (one match per
+ * present field); per the catalogue, the object-or-array shape variance
+ * is handled here in the check — a single object is treated as a
+ * one-entry list — and each entry yields its own finding via a path
+ * override. The resolution arm (condition b) applies to reference-form
+ * entries only (Definitions): an inline declaration declares what it
+ * names, so it satisfies its own resolvability and joins the candidate
+ * set for other references. Candidates come from the shared form-based
+ * machinery (`collectDeclaredIds`, also serving PDP-E-001) — inline
+ * declarations anywhere, including at reference-carrying positions;
+ * reference-form entries never declare. A same-document `@id` must
+ * resolve by exact string match; only a non-same-document full URL is
+ * exempt (external/cross-Sheet target). When both conditions hold,
+ * condition (a) wins, per the catalogue's `{problem}` definition.
+ * `{name}` is the entry's `name`, or `(unnamed)` when absent.
+ */
+const IDENTIFYING_FIELDS = ["@id", "url", "name", "sku", "gtin", "gtin13", "mpn"];
+const PROBLEM_A = "has no identifying field (`@id`, `url`, `name`, `sku`, `gtin`, `gtin13`, `mpn`)";
+export const pdpW020 = {
+    id: "PDP-W-020",
+    title: "Relationship reference lacks any identifying field",
+    severity: "warning",
+    target: "$.data['isSimilarTo','isRelatedTo','isPartOf','hasPart','pagefront:relatedProduct']",
+    check: (match, ctx) => {
+        const field = /\['([^']+)'\]$/.exec(match.path)?.[1] ?? "";
+        const entries = Array.isArray(match.value)
+            ? match.value.map((entry, i) => ({ entry, path: `${match.path}[${i}]` }))
+            : [{ entry: match.value, path: match.path }];
+        const declaredIds = collectDeclaredIds(ctx.sheet.data);
+        const hits = [];
+        for (const { entry, path } of entries) {
+            if (typeof entry !== "object" || entry === null)
+                continue;
+            const e = entry;
+            const anyIdentifying = IDENTIFYING_FIELDS.some((f) => typeof e[f] === "string" && e[f].trim() !== "");
+            let problem = null;
+            if (!anyIdentifying) {
+                problem = PROBLEM_A; // condition (a); wins when (b) also holds
+            }
+            else if (!isInlineDeclaration(e) &&
+                typeof e["@id"] === "string" &&
+                isSameDocumentId(e["@id"], ctx.sheet)) {
+                const id = e["@id"];
+                if (!declaredIds.has(id)) {
+                    problem = `declares internal \`@id\` \`${id}\` that does not resolve to any declared \`@id\` in this Sheet`;
+                }
+            }
+            if (problem === null)
+                continue;
+            const name = typeof e["name"] === "string" ? e["name"] : "(unnamed)";
+            hits.push({ path, values: { name, field, problem } });
+        }
+        return hits;
+    },
+    messageTemplate: "Relationship reference `{name}` at `{path}` in `{field}` {problem}.",
+    remediation: "Add at least one identifying field — `@id`, `url`, `name`, `sku`, `gtin`, `gtin13`, or `mpn` — so the reference is dereferenceable, displayable, or matchable. If the `@id` was meant to name an entity in this Sheet, correct it to match a declared `@id` or add that entity; if it was meant to point at another product, use the target's full URL.",
+    introduced: "v0.7",
+    specReference: "product.md#five-patterns-for-product-to-product-relationships",
+};

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

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

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

@@ -0,0 +1,53 @@
+import { isFullAbsoluteUrl, isInlineDeclaration, isSameDocumentId, } from "@pagefront/lint-core";
+/**
+ * PDP-W-021 — Cross-Sheet variant link missing `sheet_url` traversal hint.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * The target selects the `hasVariant` array (forward links) and the
+ * `isVariantOf` object (backward link); per the catalogue, the shape
+ * variance is handled here in the check, with per-entry findings via
+ * path overrides. A link is cross-Sheet by form and base together: the
+ * entry is reference form (Definitions — a stub; an inline declaration
+ * never fires, whatever its `@id`'s base) and its `@id` is a full
+ * absolute URL that is not a same-document `@id`. The earlier
+ * forward-direction inline-`offers` carve-out is subsumed by the form
+ * test (`offers` is a substantive property). `{name}` is the entry's
+ * `name`, or `(unnamed)` when absent — always `(unnamed)` on a firing
+ * entry, since a `name` would make it an inline declaration.
+ */
+function sheetUrlMissing(e) {
+    const v = e["sheet_url"];
+    return v === undefined || (typeof v === "string" && v.trim() === "");
+}
+export const pdpW021 = {
+    id: "PDP-W-021",
+    title: "Cross-Sheet variant link missing `sheet_url` traversal hint",
+    severity: "warning",
+    target: "$.data['hasVariant','isVariantOf']",
+    check: (match, ctx) => {
+        const entries = Array.isArray(match.value)
+            ? match.value.map((entry, i) => ({ entry, path: `${match.path}[${i}]` }))
+            : [{ entry: match.value, path: match.path }];
+        const hits = [];
+        for (const { entry, path } of entries) {
+            if (typeof entry !== "object" || entry === null)
+                continue;
+            const e = entry;
+            if (isInlineDeclaration(e))
+                continue; // declares its entity here, not a stub
+            if (!isFullAbsoluteUrl(e["@id"]))
+                continue; // internal @id: not a separate Sheet
+            if (isSameDocumentId(e["@id"], ctx.sheet))
+                continue; // full URL on this Sheet's base: same document
+            if (!sheetUrlMissing(e))
+                continue;
+            const name = typeof e["name"] === "string" ? e["name"] : "(unnamed)";
+            hits.push({ path, values: { name } });
+        }
+        return hits;
+    },
+    messageTemplate: "Variant link `{name}` at `{path}` appears to reference a separate Sheet by `@id` but omits the recommended `sheet_url`; consumers must reach the target Sheet via `url` + `describedby`.",
+    remediation: "Add `sheet_url` with the target's Sheet URL — the variant's Sheet URL on a parent `hasVariant` entry, or the parent's Sheet URL on a variant's `isVariantOf`. If you do not emit a separate Sheet for the target (the family is modeled inline in one ProductGroup Sheet), no cross-Sheet link exists and `sheet_url` does not apply.",
+    introduced: "v0.7",
+    specReference: "product.md#multi-sheet-variant-families",
+};

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

@@ -0,0 +1,11 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-022 — Empty product highlight entry.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires on any entry that is empty or whitespace-only. `{index}` is the
+ * entry's array position, taken from the match's resolved path. The
+ * schema types entries as strings; a non-string entry never reaches
+ * this rule on Layer-1-valid input and does not fire.
+ */
+export declare const pdpW022: Rule;

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

@@ -0,0 +1,25 @@
+/**
+ * PDP-W-022 — Empty product highlight entry.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires on any entry that is empty or whitespace-only. `{index}` is the
+ * entry's array position, taken from the match's resolved path. The
+ * schema types entries as strings; a non-string entry never reaches
+ * this rule on Layer-1-valid input and does not fire.
+ */
+export const pdpW022 = {
+    id: "PDP-W-022",
+    title: "Empty product highlight entry",
+    severity: "warning",
+    target: "$.data['pagefront:productHighlights'][*]",
+    check: (match) => {
+        if (typeof match.value !== "string" || match.value.trim() !== "")
+            return null;
+        const index = /\[(\d+)\]$/.exec(match.path)?.[1] ?? "";
+        return { values: { index } };
+    },
+    messageTemplate: "`pagefront:productHighlights[{index}]` is empty or whitespace-only; highlights must carry the publisher's selling-point text.",
+    remediation: "Populate the entry with the highlight text from the merchant's page, or remove the entry. If the pipeline cannot recover the text, drop the entry rather than emitting a placeholder — a shorter honest list beats a ranked list with blanks.",
+    introduced: "v0.8",
+    specReference: "product.md#product-highlights",
+};

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

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

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

@@ -0,0 +1,39 @@
+/**
+ * PDP-W-023 — Recall notice coexists with InStock offer.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * The target's RFC 9535 filter selects only recall notices, so the
+ * check needs no noticeType gate; `offers` is read via the rule
+ * context, per the catalogue's target line. "Either scheme variant"
+ * (PDP-W-013's equivalence): https:// or http:// schema.org InStock.
+ * `{offerPath}` is the path of the first offer declaring InStock,
+ * built in the engine's normalized path style.
+ */
+const IN_STOCK = new Set([
+    "https://schema.org/InStock",
+    "http://schema.org/InStock",
+]);
+export const pdpW023 = {
+    id: "PDP-W-023",
+    title: "Recall notice coexists with InStock offer",
+    severity: "warning",
+    target: "$.data['pagefront:safetyNotice'][?@.noticeType == 'recall']",
+    check: (_match, ctx) => {
+        const data = typeof ctx.sheet.data === "object" && ctx.sheet.data !== null
+            ? ctx.sheet.data
+            : {};
+        const offers = data["offers"];
+        if (!Array.isArray(offers))
+            return null;
+        const index = offers.findIndex((offer) => typeof offer === "object" &&
+            offer !== null &&
+            IN_STOCK.has(offer["availability"]));
+        if (index === -1)
+            return null;
+        return { values: { offerPath: `$['data']['offers'][${index}]` } };
+    },
+    messageTemplate: "Recall safety notice at `{path}` coexists with offer at `{offerPath}` declaring `InStock`; the recall overrides commercial signals and the offer data likely needs updating.",
+    remediation: "Update the offer's `availability` to reflect the corrective measure (typically `Discontinued` or `OutOfStock`). If the recall has been resolved and the product legitimately relisted, remove the stale `pagefront:safetyNotice` entry instead.",
+    introduced: "v0.8",
+    specReference: "product.md#safety-notices",
+};

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

@@ -0,0 +1,24 @@
+import { type Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-024 — Legal entity organization lacks an address.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * "Empty or whitespace-only" per the Definitions section: absent,
+ * empty string, whitespace-only string, empty array, or an object with
+ * no members. The schema types `address` as a bare object, so `{}`
+ * passes Layer 1 while declaring nothing — the memberless-object arm
+ * is the reachable one here alongside absence. `{role}` is
+ * schema-required on every entry.
+ *
+ * Reference-form organizations are exempt (v0.9): their address lives
+ * on the referenced Commerce Organization Sheet, and this linter
+ * validates one Sheet in isolation and cannot fetch that Sheet, so
+ * warning about a missing address on an explicit pointer would be a
+ * false positive. The exemption reuses the catalogue's shared form
+ * distinction — `isInlineDeclaration` — rather than a second notion of
+ * "stub": an organization carrying `@id` that is not an inline
+ * declaration is a pure reference. An organization carrying `@id`
+ * alongside substantive content (`name`, …) is an inline declaration
+ * and still fires.
+ */
+export declare const pdpW024: Rule;

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

@@ -0,0 +1,58 @@
+import { isInlineDeclaration } from "@pagefront/lint-core";
+/**
+ * PDP-W-024 — Legal entity organization lacks an address.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * "Empty or whitespace-only" per the Definitions section: absent,
+ * empty string, whitespace-only string, empty array, or an object with
+ * no members. The schema types `address` as a bare object, so `{}`
+ * passes Layer 1 while declaring nothing — the memberless-object arm
+ * is the reachable one here alongside absence. `{role}` is
+ * schema-required on every entry.
+ *
+ * Reference-form organizations are exempt (v0.9): their address lives
+ * on the referenced Commerce Organization Sheet, and this linter
+ * validates one Sheet in isolation and cannot fetch that Sheet, so
+ * warning about a missing address on an explicit pointer would be a
+ * false positive. The exemption reuses the catalogue's shared form
+ * distinction — `isInlineDeclaration` — rather than a second notion of
+ * "stub": an organization carrying `@id` that is not an inline
+ * declaration is a pure reference. An organization carrying `@id`
+ * alongside substantive content (`name`, …) is an inline declaration
+ * and still fires.
+ */
+export const pdpW024 = {
+    id: "PDP-W-024",
+    title: "Legal entity organization lacks an address",
+    severity: "warning",
+    target: "$.data['pagefront:legalEntity'][*]",
+    check: (match) => {
+        const entry = match.value;
+        if (typeof entry !== "object" || entry === null)
+            return null;
+        const e = entry;
+        const organization = typeof e["organization"] === "object" && e["organization"] !== null
+            ? e["organization"]
+            : {};
+        // Reference form (Definitions): `@id` with no members beyond
+        // `@id`/`@type`. Out of scope for this rule — see the note above.
+        if ("@id" in organization && !isInlineDeclaration(organization)) {
+            return null;
+        }
+        const address = organization["address"];
+        const missing = address === undefined ||
+            address === null ||
+            (typeof address === "string" && address.trim() === "") ||
+            (Array.isArray(address) && address.length === 0) ||
+            (typeof address === "object" &&
+                !Array.isArray(address) &&
+                Object.keys(address).length === 0);
+        if (!missing)
+            return null;
+        return { values: { role: String(e["role"]) } };
+    },
+    messageTemplate: "`pagefront:legalEntity` entry with role `{role}` at `{path}` declares an organization without an `address`.",
+    remediation: "Add the entity's postal address to the `organization`. If no address is available, the entry still identifies the organization but should not be relied on as a regulatory responsible-person declaration.",
+    introduced: "v0.8",
+    specReference: "product.md#legal-entities",
+};

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

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

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

@@ -0,0 +1,35 @@
+/**
+ * PDP-W-025 — Feature value embeds a unit in a string.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * The catalogue pattern: optional sign, digits with optional decimal
+ * separator, whitespace, then any alphabetic unit token or unit
+ * symbol. The whitespace is optional in the regex — the catalogue's
+ * own firing example `"12″"` has none. The unit token excludes digits
+ * and the separator characters, so a plain formatted number
+ * (`"1,500.00"`) is not a number-then-unit match and does not fire.
+ * `{name}` is schema-required on every feature entry.
+ */
+const NUMBER_THEN_UNIT = /^[+-]?\d+(?:[.,]\d+)?\s*[^\s0-9.,+-]+$/;
+export const pdpW025 = {
+    id: "PDP-W-025",
+    title: "Feature value embeds a unit in a string",
+    severity: "warning",
+    target: "$.data['pagefront:featureGroup'][*].feature[*]",
+    check: (match) => {
+        const entry = match.value;
+        if (typeof entry !== "object" || entry === null)
+            return null;
+        const e = entry;
+        if (e["unitCode"] !== undefined)
+            return null;
+        if (typeof e["value"] !== "string" || !NUMBER_THEN_UNIT.test(e["value"])) {
+            return null;
+        }
+        return { values: { name: String(e["name"]), value: e["value"] } };
+    },
+    messageTemplate: "Feature `{name}` at `{path}` carries value `{value}`, which parses as a number plus a unit.",
+    remediation: "Move the numeric part into `value`, express the unit as a `unitCode`, and if the merchant's display formatting matters, carry the original string in `pagefront:presentationValue`.",
+    introduced: "v0.8",
+    specReference: "product.md#feature-groups",
+};

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

@@ -0,0 +1,10 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-026 — Safety data sheet without a language declaration.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires only on entries with role `safety_data_sheet`; "lacks
+ * `inLanguage`, or … empty or whitespace-only" per the Definitions
+ * section.
+ */
+export declare const pdpW026: Rule;

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

@@ -0,0 +1,31 @@
+/**
+ * PDP-W-026 — Safety data sheet without a language declaration.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires only on entries with role `safety_data_sheet`; "lacks
+ * `inLanguage`, or … empty or whitespace-only" per the Definitions
+ * section.
+ */
+export const pdpW026 = {
+    id: "PDP-W-026",
+    title: "Safety data sheet without a language declaration",
+    severity: "warning",
+    target: "$.data['pagefront:document'][*]",
+    check: (match) => {
+        const doc = match.value;
+        if (typeof doc !== "object" || doc === null)
+            return null;
+        const d = doc;
+        if (d["role"] !== "safety_data_sheet")
+            return null;
+        const lang = d["inLanguage"];
+        const missing = lang === undefined ||
+            lang === null ||
+            (typeof lang === "string" && lang.trim() === "");
+        return missing ? {} : null;
+    },
+    messageTemplate: "Safety data sheet at `{path}` declares no `inLanguage`.",
+    remediation: "Add the document's BCP 47 language tag as `inLanguage`. If the document is multilingual, declare the primary language.",
+    introduced: "v0.8",
+    specReference: "product.md#documents",
+};

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

@@ -0,0 +1,14 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-027 — Empty accepted answer.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * The target selects `acceptedAnswer` objects, so presence is given by
+ * the match; the check tests `text` (absent, empty, or whitespace-only
+ * — the schema requires non-empty `text`, so only the whitespace arm
+ * is reachable on Layer-1-valid input; the others are defensive).
+ * `{name}` is the parent question's `name` (schema-required), read
+ * from the sheet via the match's path index; `(unnamed)` defensively
+ * on invalid input.
+ */
+export declare const pdpW027: Rule;