@pagefront/lint-commerce 0.1.0

package/dist/rules/org-shared.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared helpers for the Commerce Organization Sheet rules
+ * (ORG-W-001 … ORG-W-006). Kept local to the org rules: the notions
+ * here — the role array, the seller-block field set, the catalogue's
+ * "empty or whitespace-only" emptiness — are organization-catalogue
+ * vocabulary, not engine machinery.
+ */
+/** The Definitions section's "empty or whitespace-only". */
+export declare function isEmptyOrWhitespace(value: unknown): boolean;
+/** A field is "present" when it exists and is not empty per Definitions. */
+export declare function isPresent(data: Record<string, unknown>, field: string): boolean;
+/** The declared commerce roles, as strings; [] when absent or malformed. */
+export declare function commerceRoles(data: Record<string, unknown>): string[];
+export declare function asRecord(value: unknown): Record<string, unknown> | null;
+/**
+ * The seller-block fields whose presence implies the `seller` role
+ * (ORG-W-004) — deliberately excluding `location`, which a
+ * manufacturer legitimately carries. ORG-W-002's role-without-content
+ * check reads these plus `location`.
+ */
+export declare const SELLER_CONTENT_FIELDS: readonly ["hasMerchantReturnPolicy", "pagefront:fulfillmentTerms", "paymentAccepted"];

package/dist/rules/org-shared.js

@@ -0,0 +1,44 @@
+/**
+ * Shared helpers for the Commerce Organization Sheet rules
+ * (ORG-W-001 … ORG-W-006). Kept local to the org rules: the notions
+ * here — the role array, the seller-block field set, the catalogue's
+ * "empty or whitespace-only" emptiness — are organization-catalogue
+ * vocabulary, not engine machinery.
+ */
+/** The Definitions section's "empty or whitespace-only". */
+export function isEmptyOrWhitespace(value) {
+    return (value === undefined ||
+        value === null ||
+        (typeof value === "string" && value.trim() === "") ||
+        (Array.isArray(value) && value.length === 0) ||
+        (typeof value === "object" &&
+            !Array.isArray(value) &&
+            Object.keys(value).length === 0));
+}
+/** A field is "present" when it exists and is not empty per Definitions. */
+export function isPresent(data, field) {
+    return field in data && !isEmptyOrWhitespace(data[field]);
+}
+/** The declared commerce roles, as strings; [] when absent or malformed. */
+export function commerceRoles(data) {
+    const roles = data["pagefront:commerceRole"];
+    if (!Array.isArray(roles))
+        return [];
+    return roles.filter((r) => typeof r === "string");
+}
+export function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+/**
+ * The seller-block fields whose presence implies the `seller` role
+ * (ORG-W-004) — deliberately excluding `location`, which a
+ * manufacturer legitimately carries. ORG-W-002's role-without-content
+ * check reads these plus `location`.
+ */
+export const SELLER_CONTENT_FIELDS = [
+    "hasMerchantReturnPolicy",
+    "pagefront:fulfillmentTerms",
+    "paymentAccepted",
+];

package/dist/rules/org-w-001.d.ts

@@ -0,0 +1,12 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * ORG-W-001 — brand_owner declared without a brand node.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * organization.md: "Each declared role SHOULD have its corresponding
+ * content present — a brand_owner SHOULD carry a Brand node." The
+ * Brand.@id is the identity Product Sheets resolve via Product.brand,
+ * so a brand_owner sheet without one is undereferenceable from the
+ * product side.
+ */
+export declare const orgW001: Rule;

package/dist/rules/org-w-001.js

@@ -0,0 +1,31 @@
+import { asRecord, commerceRoles, isPresent } from "./org-shared.js";
+/**
+ * ORG-W-001 — brand_owner declared without a brand node.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * organization.md: "Each declared role SHOULD have its corresponding
+ * content present — a brand_owner SHOULD carry a Brand node." The
+ * Brand.@id is the identity Product Sheets resolve via Product.brand,
+ * so a brand_owner sheet without one is undereferenceable from the
+ * product side.
+ */
+export const orgW001 = {
+    id: "ORG-W-001",
+    title: "brand_owner declared without a brand node",
+    severity: "warning",
+    target: "$.data",
+    check: (match) => {
+        const data = asRecord(match.value);
+        if (data === null)
+            return null;
+        if (!commerceRoles(data).includes("brand_owner"))
+            return null;
+        if (isPresent(data, "brand"))
+            return null;
+        return {};
+    },
+    messageTemplate: "`pagefront:commerceRole` at `{path}` declares `brand_owner`, but the sheet carries no `brand` node.",
+    remediation: "Add the `Brand` node with `@id` and `name` — the `Brand.@id` is the identity Product Sheets resolve via `Product.brand`.",
+    introduced: "v0.9",
+    specReference: "organization.md#role-discriminator--pagefrontcommercerole",
+};

package/dist/rules/org-w-002.d.ts

@@ -0,0 +1,12 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * ORG-W-002 — seller declared without seller content.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * A `seller` role promises the store-wide terms an agent needs before
+ * it reaches a specific offer; a sheet declaring the role with none of
+ * them present is a promise with no content. `location` counts here
+ * (a physical store is seller content) even though ORG-W-004's inverse
+ * deliberately excludes it.
+ */
+export declare const orgW002: Rule;

package/dist/rules/org-w-002.js

@@ -0,0 +1,32 @@
+import { asRecord, commerceRoles, isPresent, SELLER_CONTENT_FIELDS, } from "./org-shared.js";
+/**
+ * ORG-W-002 — seller declared without seller content.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * A `seller` role promises the store-wide terms an agent needs before
+ * it reaches a specific offer; a sheet declaring the role with none of
+ * them present is a promise with no content. `location` counts here
+ * (a physical store is seller content) even though ORG-W-004's inverse
+ * deliberately excludes it.
+ */
+export const orgW002 = {
+    id: "ORG-W-002",
+    title: "seller declared without seller content",
+    severity: "warning",
+    target: "$.data",
+    check: (match) => {
+        const data = asRecord(match.value);
+        if (data === null)
+            return null;
+        if (!commerceRoles(data).includes("seller"))
+            return null;
+        const sellerFields = [...SELLER_CONTENT_FIELDS, "location"];
+        if (sellerFields.some((field) => isPresent(data, field)))
+            return null;
+        return {};
+    },
+    messageTemplate: "`pagefront:commerceRole` at `{path}` declares `seller`, but none of `hasMerchantReturnPolicy`, `pagefront:fulfillmentTerms`, `paymentAccepted`, or `location` is present.",
+    remediation: "Add the store-wide terms the seller role promises: the return policy, fulfillment terms, payment methods, or physical locations.",
+    introduced: "v0.9",
+    specReference: "organization.md#seller-block-seller",
+};

package/dist/rules/org-w-003.d.ts

@@ -0,0 +1,11 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * ORG-W-003 — Brand node without brand_owner role.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * organization.md: "content SHOULD NOT appear without its role
+ * declared." A `brand` node on a sheet not claiming `brand_owner`
+ * either means the role declaration is incomplete or the node belongs
+ * on the brand's own sheet.
+ */
+export declare const orgW003: Rule;

package/dist/rules/org-w-003.js

@@ -0,0 +1,30 @@
+import { asRecord, commerceRoles, isPresent } from "./org-shared.js";
+/**
+ * ORG-W-003 — Brand node without brand_owner role.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * organization.md: "content SHOULD NOT appear without its role
+ * declared." A `brand` node on a sheet not claiming `brand_owner`
+ * either means the role declaration is incomplete or the node belongs
+ * on the brand's own sheet.
+ */
+export const orgW003 = {
+    id: "ORG-W-003",
+    title: "Brand node without brand_owner role",
+    severity: "warning",
+    target: "$.data",
+    check: (match) => {
+        const data = asRecord(match.value);
+        if (data === null)
+            return null;
+        if (!isPresent(data, "brand"))
+            return null;
+        if (commerceRoles(data).includes("brand_owner"))
+            return null;
+        return {};
+    },
+    messageTemplate: "A `brand` node is present at `{path}`, but `pagefront:commerceRole` does not declare `brand_owner`.",
+    remediation: "Declare `brand_owner` in `pagefront:commerceRole`, or remove the `brand` node if this sheet is not the brand's sheet.",
+    introduced: "v0.9",
+    specReference: "organization.md#role-discriminator--pagefrontcommercerole",
+};

package/dist/rules/org-w-004.d.ts

@@ -0,0 +1,12 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * ORG-W-004 — seller content without seller role.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * The inverse of ORG-W-002. `location` is deliberately not in this
+ * rule's trigger set: a manufacturer legitimately declares its
+ * facilities without being a seller. Store-wide commercial terms —
+ * return policy, fulfillment terms, payment methods — are what imply
+ * the role.
+ */
+export declare const orgW004: Rule;

package/dist/rules/org-w-004.js

@@ -0,0 +1,32 @@
+import { asRecord, commerceRoles, isPresent, SELLER_CONTENT_FIELDS, } from "./org-shared.js";
+/**
+ * ORG-W-004 — seller content without seller role.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * The inverse of ORG-W-002. `location` is deliberately not in this
+ * rule's trigger set: a manufacturer legitimately declares its
+ * facilities without being a seller. Store-wide commercial terms —
+ * return policy, fulfillment terms, payment methods — are what imply
+ * the role.
+ */
+export const orgW004 = {
+    id: "ORG-W-004",
+    title: "Seller content without seller role",
+    severity: "warning",
+    target: "$.data",
+    check: (match) => {
+        const data = asRecord(match.value);
+        if (data === null)
+            return null;
+        if (commerceRoles(data).includes("seller"))
+            return null;
+        const present = SELLER_CONTENT_FIELDS.filter((field) => isPresent(data, field));
+        if (present.length === 0)
+            return null;
+        return { values: { fields: present.join("`, `") } };
+    },
+    messageTemplate: "Seller content (`{fields}`) is present at `{path}`, but `pagefront:commerceRole` does not declare `seller`.",
+    remediation: "Declare `seller` in `pagefront:commerceRole`, or move the store-wide terms to the seller's own sheet.",
+    introduced: "v0.9",
+    specReference: "organization.md#seller-block-seller",
+};

package/dist/rules/org-w-005.d.ts

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

package/dist/rules/org-w-005.js

@@ -0,0 +1,54 @@
+import { asRecord } from "./org-shared.js";
+/**
+ * ORG-W-005 — malformed registration machine key.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Checks PRESENT values only. organization.md's registration-identity
+ * rules forbid warning on absent registration identifiers — absence is
+ * jurisdiction-dependent, not a quality signal — so this rule (and the
+ * catalogue as a whole) has no presence check for `leiCode`,
+ * `iso6523Code`, `identifier`, or `sameAs`. Non-string values are
+ * Layer 1's concern (the schema types both fields as strings) and are
+ * skipped here.
+ */
+const ISO6523 = /^\d{4}:.+$/;
+const LEI = /^[A-Z0-9]{18}[0-9]{2}$/;
+export const orgW005 = {
+    id: "ORG-W-005",
+    title: "Malformed registration machine key",
+    severity: "warning",
+    target: "$.data",
+    check: (match) => {
+        const data = asRecord(match.value);
+        if (data === null)
+            return null;
+        const hits = [];
+        const iso = data["iso6523Code"];
+        if (typeof iso === "string" && !ISO6523.test(iso)) {
+            hits.push({
+                values: {
+                    field: "iso6523Code",
+                    value: iso,
+                    form: "ISO 6523 shape (four-digit ICD, colon, register number)",
+                },
+                path: `${match.path}['iso6523Code']`,
+            });
+        }
+        const lei = data["leiCode"];
+        if (typeof lei === "string" && !LEI.test(lei)) {
+            hits.push({
+                values: {
+                    field: "leiCode",
+                    value: lei,
+                    form: "ISO 17442 shape (18 alphanumerics plus 2 check digits)",
+                },
+                path: `${match.path}['leiCode']`,
+            });
+        }
+        return hits.length > 0 ? hits : null;
+    },
+    messageTemplate: "`{field}` at `{path}` carries `{value}`, which does not match the {form}.",
+    remediation: "Correct the machine key: `iso6523Code` is `NNNN:register-number` (e.g. `0002:808641435` for a SIREN), `leiCode` is a 20-character ISO 17442 LEI. If no well-formed machine key exists for this register, drop the field and keep the display-form `identifier` — absence is conformant.",
+    introduced: "v0.9",
+    specReference: "organization.md#company-registration-identity",
+};

package/dist/rules/org-w-006.d.ts

@@ -0,0 +1,13 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * ORG-W-006 — authorized resellers without brand_owner role.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Content-without-role, in the ORG-W-003/ORG-W-004 family.
+ * `pagefront:authorizedResellers` is the brand exercising authority
+ * over its own distribution, so organization.md admits it only where
+ * `commerceRole` includes `brand_owner`; a reseller's own claim of
+ * authorization carries no weight. Presence-only: no rule warns on the
+ * field's absence — absence is no statement.
+ */
+export declare const orgW006: Rule;

package/dist/rules/org-w-006.js

@@ -0,0 +1,32 @@
+import { asRecord, commerceRoles, isPresent } from "./org-shared.js";
+/**
+ * ORG-W-006 — authorized resellers without brand_owner role.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Content-without-role, in the ORG-W-003/ORG-W-004 family.
+ * `pagefront:authorizedResellers` is the brand exercising authority
+ * over its own distribution, so organization.md admits it only where
+ * `commerceRole` includes `brand_owner`; a reseller's own claim of
+ * authorization carries no weight. Presence-only: no rule warns on the
+ * field's absence — absence is no statement.
+ */
+export const orgW006 = {
+    id: "ORG-W-006",
+    title: "Authorized resellers without brand_owner role",
+    severity: "warning",
+    target: "$.data",
+    check: (match) => {
+        const data = asRecord(match.value);
+        if (data === null)
+            return null;
+        if (!isPresent(data, "pagefront:authorizedResellers"))
+            return null;
+        if (commerceRoles(data).includes("brand_owner"))
+            return null;
+        return {};
+    },
+    messageTemplate: "`pagefront:authorizedResellers` is present at `{path}`, but `pagefront:commerceRole` does not declare `brand_owner`.",
+    remediation: "Declare `brand_owner` in `pagefront:commerceRole` if this is the brand's own sheet; otherwise remove the field — only the brand's sheet can state whom the brand authorizes.",
+    introduced: "v0.9",
+    specReference: "organization.md#authorized-resellers",
+};

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

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

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

@@ -0,0 +1,42 @@
+import { collectDeclaredIds, isInlineDeclaration, isSameDocumentId, valueAtPath, } from "@pagefront/lint-core";
+/**
+ * PDP-E-001 — Broken @id reference.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * The target matches every `@id` in the Sheet; the check fires only on
+ * *reference-form* usages (Definitions) inside the schema-derived
+ * reference-carrying fields (`itemOffered` on `offers` entries,
+ * `isVariantOf`), detected from the match path. The form test examines
+ * the object carrying the matched `@id` (parent of the match): an
+ * inline declaration there is not a reference — it declares its `@id`
+ * into the resolution candidate set instead (`collectDeclaredIds`, the
+ * form-based machinery shared with PDP-W-020). For a reference-form entry,
+ * 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.
+ */
+const REFERENCE_SEGMENT = /\['itemOffered'\]|\['isVariantOf'\]/;
+export const pdpE001 = {
+    id: "PDP-E-001",
+    title: "Broken @id reference",
+    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;
+        const carrier = valueAtPath(ctx.sheet, match.path.replace(/\['@id'\]$/, ""));
+        if (isInlineDeclaration(carrier))
+            return null; // declares, not references
+        if (!isSameDocumentId(value, ctx.sheet))
+            return null; // cross-Sheet: URL shape is given
+        const resolves = collectDeclaredIds(ctx.sheet.data).has(value);
+        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.",
+    introduced: "v0.6",
+    specReference: "product.md#itemoffered-references",
+};

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

@@ -0,0 +1,13 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-E-002 — Format version / schema mismatch.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * `$schema` is read via the rule context, per the target line. The
+ * version segment is the trailing `v<version>.json` of the `$schema`
+ * URL. Two quiet cases, both documented readings: `$schema` absent
+ * (optional at Layer 1 — nothing to compare), and a `$schema` with no
+ * parseable version segment (it declares no version, so no mismatch
+ * can be asserted; the message requires `{schema_version}`).
+ */
+export declare const pdpE002: Rule;

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

@@ -0,0 +1,33 @@
+/**
+ * PDP-E-002 — Format version / schema mismatch.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * `$schema` is read via the rule context, per the target line. The
+ * version segment is the trailing `v<version>.json` of the `$schema`
+ * URL. Two quiet cases, both documented readings: `$schema` absent
+ * (optional at Layer 1 — nothing to compare), and a `$schema` with no
+ * parseable version segment (it declares no version, so no mismatch
+ * can be asserted; the message requires `{schema_version}`).
+ */
+export const pdpE002 = {
+    id: "PDP-E-002",
+    title: "Format version / schema mismatch",
+    severity: "error",
+    target: "$.format_version",
+    check: (match, ctx) => {
+        const formatVersion = String(match.value);
+        const schema = ctx.sheet.$schema;
+        if (typeof schema !== "string")
+            return null;
+        const segment = /v(\d+(?:\.\d+)*)\.json$/.exec(schema);
+        if (segment === null)
+            return null;
+        return segment[1] === formatVersion
+            ? null
+            : { values: { format_version: formatVersion, schema_version: segment[1] } };
+    },
+    messageTemplate: "`format_version` is `{format_version}` but `$schema` URL declares version `{schema_version}`.",
+    remediation: "Align both fields to the same version. Whichever version was intended, update the other field to match.",
+    introduced: "v0.6",
+    specReference: "product.md#the-envelope",
+};

package/dist/rules/pdp-i-001.d.ts

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

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

@@ -0,0 +1,28 @@
+import { DATA_BLOCK_PROPERTIES } from "../schema-properties.js";
+/**
+ * PDP-I-001 — Property outside Pagefront's modeled set.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * The modeled set is the JSON Schema's dataBlock property inventory
+ * (schema-properties.ts, drift-tested against product.json). The
+ * target `$.data.*` selects top-level data properties by design; any
+ * property outside the inventory fires, including unmodeled
+ * `pagefront:`-prefixed ones.
+ */
+const MODELED = new Set(DATA_BLOCK_PROPERTIES);
+export const pdpI001 = {
+    id: "PDP-I-001",
+    title: "Property outside Pagefront's modeled set",
+    severity: "info",
+    target: "$.data.*",
+    check: (match) => {
+        const property = /\['([^']+)'\]$/.exec(match.path)?.[1];
+        if (property === undefined || MODELED.has(property))
+            return null;
+        return { values: { property } };
+    },
+    messageTemplate: "Property `{property}` at `{path}` is valid Schema.org but is not explicitly modeled by Pagefront.",
+    remediation: "No action required. This finding is informational. If you find yourself using a Schema.org property frequently and would value formal Pagefront modeling for it, consider opening a spec proposal.",
+    introduced: "v0.6",
+    specReference: "product.md#data--schemaorg-json-ld",
+};

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

@@ -0,0 +1,12 @@
+import { type Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-001 — Recommended field absent: image.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Spec check: "`data.image` is absent, or is an empty array."
+ * `fieldAbsentOrEmpty` additionally fires on null and empty/whitespace
+ * strings — inputs a Layer-1-valid Sheet cannot present for `image`
+ * (the schema types it as an array), so the check is equivalent on the
+ * linter's input domain.
+ */
+export declare const pdpW001: Rule;

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

@@ -0,0 +1,22 @@
+import { fieldAbsentOrEmpty } from "@pagefront/lint-core";
+/**
+ * PDP-W-001 — Recommended field absent: image.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Spec check: "`data.image` is absent, or is an empty array."
+ * `fieldAbsentOrEmpty` additionally fires on null and empty/whitespace
+ * strings — inputs a Layer-1-valid Sheet cannot present for `image`
+ * (the schema types it as an array), so the check is equivalent on the
+ * linter's input domain.
+ */
+export const pdpW001 = {
+    id: "PDP-W-001",
+    title: "Recommended field absent: image",
+    severity: "warning",
+    target: "$.data",
+    check: fieldAbsentOrEmpty("image"),
+    messageTemplate: "No images declared at `{path}`.",
+    remediation: "Add at least one `ImageObject` to the `data.image` array. The primary image should typically declare role `hero` or `packshot`.",
+    introduced: "v0.6",
+    specReference: "product.md#image-roles",
+};

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

@@ -0,0 +1,13 @@
+import { type Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-002 — Recommended field absent: description.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Spec check: "`data.description` is absent or empty." The helper's
+ * empty-array and null cases are unreachable — the schema types
+ * `description` as a string. The helper also treats a whitespace-only
+ * string as empty; the catalogue says only "empty", so this is a
+ * deliberate reading (consistent with the catalogue rules that spell
+ * out "empty or whitespace-only").
+ */
+export declare const pdpW002: Rule;

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

@@ -0,0 +1,23 @@
+import { fieldAbsentOrEmpty } from "@pagefront/lint-core";
+/**
+ * PDP-W-002 — Recommended field absent: description.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Spec check: "`data.description` is absent or empty." The helper's
+ * empty-array and null cases are unreachable — the schema types
+ * `description` as a string. The helper also treats a whitespace-only
+ * string as empty; the catalogue says only "empty", so this is a
+ * deliberate reading (consistent with the catalogue rules that spell
+ * out "empty or whitespace-only").
+ */
+export const pdpW002 = {
+    id: "PDP-W-002",
+    title: "Recommended field absent: description",
+    severity: "warning",
+    target: "$.data",
+    check: fieldAbsentOrEmpty("description"),
+    messageTemplate: "No description at `{path}`.",
+    remediation: "Add a `description` field with a 1–3 paragraph prose description of the product. The description should match the Sheet's `inLanguage`.",
+    introduced: "v0.6",
+    specReference: "product.md#required-and-recommended-core-fields",
+};

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

@@ -0,0 +1,12 @@
+import { type Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-003 — Recommended field absent: brand.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Spec check: "`data.brand` is absent." The helper additionally fires on
+ * null, empty arrays, and empty/whitespace strings — all unreachable for
+ * `brand`, which the schema types as an object; and it does not fire on
+ * an empty object. On Layer-1-valid input the helper is therefore
+ * exactly "absent".
+ */
+export declare const pdpW003: Rule;

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

@@ -0,0 +1,22 @@
+import { fieldAbsentOrEmpty } from "@pagefront/lint-core";
+/**
+ * PDP-W-003 — Recommended field absent: brand.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Spec check: "`data.brand` is absent." The helper additionally fires on
+ * null, empty arrays, and empty/whitespace strings — all unreachable for
+ * `brand`, which the schema types as an object; and it does not fire on
+ * an empty object. On Layer-1-valid input the helper is therefore
+ * exactly "absent".
+ */
+export const pdpW003 = {
+    id: "PDP-W-003",
+    title: "Recommended field absent: brand",
+    severity: "warning",
+    target: "$.data",
+    check: fieldAbsentOrEmpty("brand"),
+    messageTemplate: "No brand declared at `{path}`.",
+    remediation: "Add a `brand` field with a typed `Brand` or `Organization` value, including at minimum `name` and optionally `url`.",
+    introduced: "v0.6",
+    specReference: "product.md#required-and-recommended-core-fields",
+};

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

@@ -0,0 +1,11 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-W-004 — Offer price without currency.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Bespoke cross-field check: fires when the offer has `price` but
+ * neither `priceCurrency` nor `priceSpecification`. The target matches
+ * every `offers` entry (Offer or AggregateOffer); the check is
+ * type-agnostic, since a bare `price` is equally ambiguous on either.
+ */
+export declare const pdpW004: Rule;

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

@@ -0,0 +1,30 @@
+/**
+ * PDP-W-004 — Offer price without currency.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Bespoke cross-field check: fires when the offer has `price` but
+ * neither `priceCurrency` nor `priceSpecification`. The target matches
+ * every `offers` entry (Offer or AggregateOffer); the check is
+ * type-agnostic, since a bare `price` is equally ambiguous on either.
+ */
+export const pdpW004 = {
+    id: "PDP-W-004",
+    title: "Offer price without currency",
+    severity: "warning",
+    target: "$.data.offers[*]",
+    check: (match) => {
+        const offer = match.value;
+        if (typeof offer !== "object" || offer === null)
+            return null;
+        const o = offer;
+        return o["price"] !== undefined &&
+            o["priceCurrency"] === undefined &&
+            o["priceSpecification"] === undefined
+            ? {}
+            : null;
+    },
+    messageTemplate: "Offer at `{path}` has `price` but no `priceCurrency`.",
+    remediation: "Add a `priceCurrency` field with the ISO 4217 currency code matching the offer's currency.",
+    introduced: "v0.6",
+    specReference: "product.md#offers",
+};