@pagefront/lint-commerce 0.12.0 → 0.13.0

package/dist/index.d.ts

@@ -5,8 +5,8 @@
  * else: `lintSheet` (Layer 2 only, for already-validated Sheets),
  * `validateAndLint` (Layer 1 → Layer 2, the CLI's own pipeline),
  * `validateOrganizationSheet` (Layer 1 for the Commerce Organization
- * Sheet; no organization catalogue exists yet), the commerce
- * catalogue object, and the types those signatures mention.
+ * Sheet alone), the three page-type catalogue objects, and the types
+ * those signatures mention.
  * The bundled schemas (`generated/`), the compiled validators and the
  * individual rule modules are internal. The release manifest
  * (`RELEASE_MANIFEST`, `sheetSpecVersionFor`, `schemaUrlFor`) and the
@@ -21,6 +21,7 @@ export { validateOrganizationSheet } from "./validate-organization.js";
 export type { ValidateOrganizationResult } from "./validate-organization.js";
 export { commerceCatalogue } from "./catalogue.js";
 export { organizationCatalogue } from "./organization-catalogue.js";
+export { collectionCatalogue } from "./collection-catalogue.js";
 export { detectSheetType, detectSheetLine } from "./sheet-type.js";
 export type { SheetType, SheetLine } from "./sheet-type.js";
 export { RELEASE_MANIFEST, KNOWN_RELEASES, CURRENT_RELEASE, sheetSpecVersionFor, schemaUrlFor, } from "./releases.js";

package/dist/index.js

@@ -5,8 +5,8 @@
  * else: `lintSheet` (Layer 2 only, for already-validated Sheets),
  * `validateAndLint` (Layer 1 → Layer 2, the CLI's own pipeline),
  * `validateOrganizationSheet` (Layer 1 for the Commerce Organization
- * Sheet; no organization catalogue exists yet), the commerce
- * catalogue object, and the types those signatures mention.
+ * Sheet alone), the three page-type catalogue objects, and the types
+ * those signatures mention.
  * The bundled schemas (`generated/`), the compiled validators and the
  * individual rule modules are internal. The release manifest
  * (`RELEASE_MANIFEST`, `sheetSpecVersionFor`, `schemaUrlFor`) and the
@@ -19,6 +19,7 @@ export { validateAndLint } from "./validate-and-lint.js";
 export { validateOrganizationSheet } from "./validate-organization.js";
 export { commerceCatalogue } from "./catalogue.js";
 export { organizationCatalogue } from "./organization-catalogue.js";
+export { collectionCatalogue } from "./collection-catalogue.js";
 export { detectSheetType, detectSheetLine } from "./sheet-type.js";
 export { RELEASE_MANIFEST, KNOWN_RELEASES, CURRENT_RELEASE, sheetSpecVersionFor, schemaUrlFor, } from "./releases.js";
 export { SCHEMA_IDS as BUNDLED_SCHEMA_IDS } from "./generated/schema-ids.js";

package/dist/lint-sheet.d.ts

@@ -2,9 +2,10 @@ import type { LintOptions, Report, Sheet } from "@pagefront/lint-core";
 /**
  * Lint a Sheet against the commerce rule catalogue for its page type:
  * the product catalogue for product sheets, the organization catalogue
- * for Commerce Organization Sheets, dispatched by sheet-type detection
- * (see sheet-type.ts). Product rules never run on organization sheets
- * and vice versa.
+ * for Commerce Organization Sheets, the collection catalogue for
+ * Commerce Collection Sheets, dispatched by sheet-type detection (see
+ * sheet-type.ts). No page type's rules run on another page type's
+ * sheets.
  *
  * `Report.linter_version` identifies the invoking implementation, so the
  * default here is this package's version — lint-core's own fallback (its

package/dist/lint-sheet.js

@@ -1,14 +1,16 @@
 import { lint } from "@pagefront/lint-core";
 import { commerceCatalogue } from "./catalogue.js";
+import { collectionCatalogue } from "./collection-catalogue.js";
 import { organizationCatalogue } from "./organization-catalogue.js";
 import { detectSheetType } from "./sheet-type.js";
 import { PACKAGE_VERSION } from "./version.js";
 /**
  * Lint a Sheet against the commerce rule catalogue for its page type:
  * the product catalogue for product sheets, the organization catalogue
- * for Commerce Organization Sheets, dispatched by sheet-type detection
- * (see sheet-type.ts). Product rules never run on organization sheets
- * and vice versa.
+ * for Commerce Organization Sheets, the collection catalogue for
+ * Commerce Collection Sheets, dispatched by sheet-type detection (see
+ * sheet-type.ts). No page type's rules run on another page type's
+ * sheets.
  *
  * `Report.linter_version` identifies the invoking implementation, so the
  * default here is this package's version — lint-core's own fallback (its
@@ -18,8 +20,9 @@ export function lintSheet(sheet, options) {
     const opts = { ...options };
     if (opts.linterVersion === undefined)
         opts.linterVersion = PACKAGE_VERSION;
-    const catalogue = detectSheetType(sheet) === "organization"
-        ? organizationCatalogue
-        : commerceCatalogue;
+    const type = detectSheetType(sheet);
+    const catalogue = type === "organization" ? organizationCatalogue
+        : type === "collection" ? collectionCatalogue
+            : commerceCatalogue;
     return lint(sheet, catalogue, opts);
 }

package/dist/organization-catalogue.d.ts

@@ -3,9 +3,9 @@ import type { Catalogue } from "@pagefront/lint-core";
  * The Commerce Organization Sheet rule catalogue — the executable form
  * of the "Commerce Organization Sheet rules" section of
  * commerce/spec/rules.md (normative). It shares rules.md's catalogue
- * version with the product catalogue: one normative document, one
- * version, two page-type rule sets dispatched by sheet type (see
- * sheet-type.ts). Product rules never run on organization sheets and
- * vice versa.
+ * version with the product and collection catalogues: one normative
+ * document, one version, three page-type rule sets dispatched by sheet
+ * type (see sheet-type.ts). No page type's rules run on another page
+ * type's sheets.
  */
 export declare const organizationCatalogue: Catalogue;

package/dist/organization-catalogue.js

@@ -9,18 +9,19 @@ import { orgW003 } from "./rules/org-w-003.js";
 import { orgW004 } from "./rules/org-w-004.js";
 import { orgW005 } from "./rules/org-w-005.js";
 import { orgW006 } from "./rules/org-w-006.js";
+import { orgW007 } from "./rules/org-w-007.js";
 /**
  * The Commerce Organization Sheet rule catalogue — the executable form
  * of the "Commerce Organization Sheet rules" section of
  * commerce/spec/rules.md (normative). It shares rules.md's catalogue
- * version with the product catalogue: one normative document, one
- * version, two page-type rule sets dispatched by sheet type (see
- * sheet-type.ts). Product rules never run on organization sheets and
- * vice versa.
+ * version with the product and collection catalogues: one normative
+ * document, one version, three page-type rule sets dispatched by sheet
+ * type (see sheet-type.ts). No page type's rules run on another page
+ * type's sheets.
  */
 export const organizationCatalogue = {
     vertical: "commerce",
     releases: KNOWN_RELEASES,
-    catalogueVersion: "0.16.0",
-    rules: [orgE001, orgE002, orgE003, orgE004, orgW001, orgW002, orgW003, orgW004, orgW005, orgW006],
+    catalogueVersion: "0.17.0",
+    rules: [orgE001, orgE002, orgE003, orgE004, orgW001, orgW002, orgW003, orgW004, orgW005, orgW006, orgW007],
 };

package/dist/overrides.d.ts

@@ -0,0 +1,36 @@
+import type { ValidateFunction } from "ajv";
+import type { SheetType } from "./sheet-type.js";
+/**
+ * The shape of the release manifest (commerce/spec/releases.json), as
+ * the registry reads it: each release names the member versions it
+ * bundles, and a sheet type a release does not bundle is absent.
+ */
+export interface ManifestRelease {
+    release: string;
+    date: string;
+    vocabulary: string;
+    sheets: Readonly<Partial<Record<SheetType, string>>>;
+}
+export interface ReleaseManifestShape {
+    schema_url_template: string;
+    releases: readonly ManifestRelease[];
+    legacy: {
+        envelope_field: string;
+        format_versions: readonly string[];
+        schemas: Readonly<Partial<Record<SheetType, string>>>;
+    };
+}
+/**
+ * Test-only overrides of what the package bundles: a release manifest
+ * other than commerce/spec/releases.json, and Layer 1 validators for
+ * schema ids the frozen store does not carry (an editable head). The
+ * production code path never sets them, so it reads the bundled
+ * manifest and the compiled validators; tests install them through
+ * test-hooks.ts to exercise a release before it lands.
+ */
+export interface TestOverrides {
+    manifest?: ReleaseManifestShape;
+    validators?: Readonly<Record<string, ValidateFunction>>;
+}
+export declare const overrides: () => TestOverrides;
+export declare const setOverrides: (next: TestOverrides) => void;

package/dist/overrides.js

@@ -0,0 +1,5 @@
+let active = {};
+export const overrides = () => active;
+export const setOverrides = (next) => {
+    active = next;
+};

package/dist/releases.d.ts

@@ -1,22 +1,37 @@
 import { RELEASE_MANIFEST } from "./generated/release-manifest.js";
+import { type ReleaseManifestShape } from "./overrides.js";
 import type { SheetType } from "./sheet-type.js";
 /**
  * The commerce release manifest (commerce/spec/releases.json): each
  * release and the member versions it bundles. Bundled at build time by
  * scripts/bundle-schemas.mjs, so the package always carries the
- * manifest it was built from.
+ * manifest it was built from. The exported constants describe the
+ * bundled manifest; the functions below read the manifest in force,
+ * which is the bundled one unless a test installed another through
+ * test-hooks.ts.
  */
 export { RELEASE_MANIFEST };
-/** Every release the manifest lists, in manifest order. */
+/** Every release the bundled manifest lists, in manifest order. */
 export declare const KNOWN_RELEASES: readonly string[];
-/** The latest release the manifest lists. */
+/** The latest release the bundled manifest lists. */
 export declare const CURRENT_RELEASE: string;
+/** The manifest in force: the bundled one, or the one a test installed. */
+export declare function manifest(): ReleaseManifestShape;
+/** Every release the manifest in force lists, in manifest order. */
+export declare function knownReleases(): readonly string[];
+/** The latest release the manifest in force lists. */
+export declare function currentRelease(): string;
 /**
  * The sheet-spec version a release bundles for a sheet type, or
- * undefined when the manifest does not list the release.
+ * undefined when the manifest does not list the release, or lists it
+ * without that sheet type (a type that joined the line in a later
+ * release).
  */
 export declare function sheetSpecVersionFor(release: string, sheetType: SheetType): string | undefined;
 /** The published URL of a sheet spec's JSON Schema, which is also its `$id`. */
 export declare function schemaUrlFor(sheetType: SheetType, version: string): string;
-/** The legacy draft line's schema URL for a sheet type. */
-export declare function legacySchemaUrl(sheetType: SheetType): string;
+/**
+ * The legacy draft line's schema URL for a sheet type, or undefined for
+ * a type that was never on that line (the collection sheet).
+ */
+export declare function legacySchemaUrl(sheetType: SheetType): string | undefined;

package/dist/releases.js

@@ -1,27 +1,49 @@
 import { RELEASE_MANIFEST } from "./generated/release-manifest.js";
+import { overrides } from "./overrides.js";
 /**
  * The commerce release manifest (commerce/spec/releases.json): each
  * release and the member versions it bundles. Bundled at build time by
  * scripts/bundle-schemas.mjs, so the package always carries the
- * manifest it was built from.
+ * manifest it was built from. The exported constants describe the
+ * bundled manifest; the functions below read the manifest in force,
+ * which is the bundled one unless a test installed another through
+ * test-hooks.ts.
  */
 export { RELEASE_MANIFEST };
-/** Every release the manifest lists, in manifest order. */
+/** Every release the bundled manifest lists, in manifest order. */
 export const KNOWN_RELEASES = RELEASE_MANIFEST.releases.map((r) => r.release);
-/** The latest release the manifest lists. */
+/** The latest release the bundled manifest lists. */
 export const CURRENT_RELEASE = KNOWN_RELEASES[KNOWN_RELEASES.length - 1];
+/** The manifest in force: the bundled one, or the one a test installed. */
+export function manifest() {
+    return overrides().manifest ?? RELEASE_MANIFEST;
+}
+/** Every release the manifest in force lists, in manifest order. */
+export function knownReleases() {
+    return manifest().releases.map((r) => r.release);
+}
+/** The latest release the manifest in force lists. */
+export function currentRelease() {
+    const releases = knownReleases();
+    return releases[releases.length - 1];
+}
 /**
  * The sheet-spec version a release bundles for a sheet type, or
- * undefined when the manifest does not list the release.
+ * undefined when the manifest does not list the release, or lists it
+ * without that sheet type (a type that joined the line in a later
+ * release).
  */
 export function sheetSpecVersionFor(release, sheetType) {
-    return RELEASE_MANIFEST.releases.find((r) => r.release === release)?.sheets[sheetType];
+    return manifest().releases.find((r) => r.release === release)?.sheets[sheetType];
 }
 /** The published URL of a sheet spec's JSON Schema, which is also its `$id`. */
 export function schemaUrlFor(sheetType, version) {
-    return RELEASE_MANIFEST.schema_url_template.replace("{sheet}", sheetType).replace("{version}", version);
+    return manifest().schema_url_template.replace("{sheet}", sheetType).replace("{version}", version);
 }
-/** The legacy draft line's schema URL for a sheet type. */
+/**
+ * The legacy draft line's schema URL for a sheet type, or undefined for
+ * a type that was never on that line (the collection sheet).
+ */
 export function legacySchemaUrl(sheetType) {
-    return RELEASE_MANIFEST.legacy.schemas[sheetType];
+    return manifest().legacy.schemas[sheetType];
 }

package/dist/rules/checkout-template.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Shared by PDP-E-019 and PDP-E-020: the checkout template an Offer may
+ * carry as Schema.org's `checkoutPageURLTemplate` (product.md, "Where to
+ * buy"), and the RFC 6570 syntax check PDP-E-019 applies to it.
+ *
+ * The syntax check follows the RFC's grammar (sections 2.1 to 2.4):
+ *
+ *   expression    = "{" [ operator ] variable-list "}"
+ *   operator      = "+" / "#" / "." / "/" / ";" / "?" / "&"   (levels 2 and 3)
+ *                 / "=" / "," / "!" / "@" / "|"                (reserved)
+ *   variable-list = varspec *( "," varspec )
+ *   varspec       = varname [ ":" max-length / "*" ]
+ *   varname       = varchar *( ["."] varchar )
+ *   varchar       = ALPHA / DIGIT / "_" / pct-encoded
+ *
+ * Literals outside an expression may be any character except a control
+ * character, a space, `"`, `'`, `%` (unless it starts a pct-encoded
+ * triplet), `<`, `>`, `\`, `^`, `` ` ``, `{`, `|` and `}`. The reserved
+ * operators are a template error here: the RFC reserves them for future
+ * extensions and defines no expansion for them.
+ *
+ * Expansion (section 3.2) is implemented for the one defined variable,
+ * a scalar: the operator sets the expression's first character and the
+ * separator between varspecs, and `;`, `?` and `&` prefix the value with
+ * `name=`; a prefix modifier truncates the value; explode has no effect
+ * on a scalar; an undefined variable expands to nothing.
+ */
+/** The one template variable the Product Sheet spec defines. */
+export declare const DEFINED_VARIABLES: readonly string[];
+export type TemplateProblem = {
+    kind: "not-string";
+} | {
+    kind: "invalid";
+    detail: string;
+} | {
+    kind: "undefined-variables";
+    variables: string[];
+} | {
+    kind: "not-https";
+    expansion: string;
+};
+/**
+ * Parse an RFC 6570 template. Returns the variable names it references
+ * (each once, in order of appearance), or the first syntax problem.
+ */
+export declare function parseTemplate(template: string): {
+    variables: string[];
+} | {
+    detail: string;
+};
+/**
+ * Expand a template that `parseTemplate` accepted, with scalar string
+ * values. Values are used as given (the one defined value, "1", needs no
+ * encoding). A variable missing from `values` is undefined and expands
+ * to nothing, as the RFC prescribes.
+ */
+export declare function expandTemplate(template: string, values: Record<string, string>): string;
+/** True when `value` is a full absolute URL with the scheme `https`. */
+export declare function isAbsoluteHttpsUrl(value: unknown): boolean;
+/** True when `value` is a full absolute URL with the scheme `http` or `https`. */
+export declare function isAbsoluteHttpUrl(value: unknown): boolean;
+/**
+ * The problem with an Offer's `checkoutPageURLTemplate`, if any: the
+ * first of syntax, undefined variables, and the expansion with
+ * `quantity` set to 1 not being an absolute https URL.
+ */
+export declare function checkoutTemplateProblem(value: unknown): TemplateProblem | null;
+/** Whether a region property is present and not empty or whitespace-only. */
+export declare function declaresRegion(offer: Record<string, unknown>): boolean;

package/dist/rules/checkout-template.js

@@ -0,0 +1,165 @@
+import { isFullAbsoluteUrl } from "@pagefront/lint-core";
+import { asObject, own } from "./configurator-pricing.js";
+/**
+ * Shared by PDP-E-019 and PDP-E-020: the checkout template an Offer may
+ * carry as Schema.org's `checkoutPageURLTemplate` (product.md, "Where to
+ * buy"), and the RFC 6570 syntax check PDP-E-019 applies to it.
+ *
+ * The syntax check follows the RFC's grammar (sections 2.1 to 2.4):
+ *
+ *   expression    = "{" [ operator ] variable-list "}"
+ *   operator      = "+" / "#" / "." / "/" / ";" / "?" / "&"   (levels 2 and 3)
+ *                 / "=" / "," / "!" / "@" / "|"                (reserved)
+ *   variable-list = varspec *( "," varspec )
+ *   varspec       = varname [ ":" max-length / "*" ]
+ *   varname       = varchar *( ["."] varchar )
+ *   varchar       = ALPHA / DIGIT / "_" / pct-encoded
+ *
+ * Literals outside an expression may be any character except a control
+ * character, a space, `"`, `'`, `%` (unless it starts a pct-encoded
+ * triplet), `<`, `>`, `\`, `^`, `` ` ``, `{`, `|` and `}`. The reserved
+ * operators are a template error here: the RFC reserves them for future
+ * extensions and defines no expansion for them.
+ *
+ * Expansion (section 3.2) is implemented for the one defined variable,
+ * a scalar: the operator sets the expression's first character and the
+ * separator between varspecs, and `;`, `?` and `&` prefix the value with
+ * `name=`; a prefix modifier truncates the value; explode has no effect
+ * on a scalar; an undefined variable expands to nothing.
+ */
+/** The one template variable the Product Sheet spec defines. */
+export const DEFINED_VARIABLES = ["quantity"];
+const VARSPEC = /^(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})(?:\.?(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2}))*(?:\*|:[1-9][0-9]{0,3})?$/;
+const LEVEL_OPERATORS = new Set(["+", "#", ".", "/", ";", "?", "&"]);
+const RESERVED_OPERATORS = new Set(["=", ",", "!", "@", "|"]);
+const EXCLUDED_LITERALS = new Set(['"', "'", "<", ">", "\\", "^", "`", "|"]);
+/** The variable name of a varspec, without its prefix or explode modifier. */
+function varnameOf(varspec) {
+    return varspec.replace(/(?:\*|:[1-9][0-9]{0,3})$/, "");
+}
+/**
+ * Parse an RFC 6570 template. Returns the variable names it references
+ * (each once, in order of appearance), or the first syntax problem.
+ */
+export function parseTemplate(template) {
+    const variables = [];
+    let i = 0;
+    while (i < template.length) {
+        const ch = template[i];
+        if (ch === "{") {
+            const close = template.indexOf("}", i + 1);
+            if (close === -1)
+                return { detail: `the expression opened at position ${i} is never closed` };
+            let body = template.slice(i + 1, close);
+            if (body.length === 0)
+                return { detail: `the expression at position ${i} is empty` };
+            if (RESERVED_OPERATORS.has(body[0])) {
+                return { detail: `the operator \`${body[0]}\` at position ${i + 1} is reserved by RFC 6570 and has no expansion` };
+            }
+            if (LEVEL_OPERATORS.has(body[0]))
+                body = body.slice(1);
+            for (const varspec of body.split(",")) {
+                if (!VARSPEC.test(varspec))
+                    return { detail: `\`${varspec}\` in the expression at position ${i} is not a variable specifier` };
+                const name = varnameOf(varspec);
+                if (!variables.includes(name))
+                    variables.push(name);
+            }
+            i = close + 1;
+            continue;
+        }
+        if (ch === "}")
+            return { detail: `\`}\` at position ${i} is outside an expression` };
+        if (ch === "%") {
+            if (!/^%[0-9A-Fa-f]{2}/.test(template.slice(i, i + 3))) {
+                return { detail: `\`%\` at position ${i} does not start a percent-encoded triplet` };
+            }
+            i += 3;
+            continue;
+        }
+        const code = ch.charCodeAt(0);
+        if (code < 0x20 || code === 0x7f || ch === " " || EXCLUDED_LITERALS.has(ch)) {
+            const shown = code < 0x20 || code === 0x7f ? `U+${code.toString(16).toUpperCase().padStart(4, "0")}` : ch === " " ? "a space" : `\`${ch}\``;
+            return { detail: `${shown} at position ${i} is not allowed in a literal` };
+        }
+        i += 1;
+    }
+    return { variables };
+}
+/** Expansion rules per operator (RFC 6570, section 3.2, table at 3.2.1). */
+const EXPANSION = {
+    "": { first: "", sep: ",", named: false },
+    "+": { first: "", sep: ",", named: false },
+    "#": { first: "#", sep: ",", named: false },
+    ".": { first: ".", sep: ".", named: false },
+    "/": { first: "/", sep: "/", named: false },
+    ";": { first: ";", sep: ";", named: true },
+    "?": { first: "?", sep: "&", named: true },
+    "&": { first: "&", sep: "&", named: true },
+};
+/**
+ * Expand a template that `parseTemplate` accepted, with scalar string
+ * values. Values are used as given (the one defined value, "1", needs no
+ * encoding). A variable missing from `values` is undefined and expands
+ * to nothing, as the RFC prescribes.
+ */
+export function expandTemplate(template, values) {
+    return template.replace(/\{([^}]*)\}/g, (_, body) => {
+        const operator = LEVEL_OPERATORS.has(body[0]) ? body[0] : "";
+        const rule = EXPANSION[operator];
+        const parts = [];
+        for (const varspec of (operator === "" ? body : body.slice(1)).split(",")) {
+            const name = varnameOf(varspec);
+            if (!(name in values))
+                continue;
+            let value = values[name];
+            const prefix = /:([1-9][0-9]{0,3})$/.exec(varspec);
+            if (prefix !== null)
+                value = value.slice(0, Number(prefix[1]));
+            if (rule.named) {
+                parts.push(operator === ";" && value === "" ? name : `${name}=${value}`);
+            }
+            else {
+                parts.push(value);
+            }
+        }
+        return parts.length === 0 ? "" : rule.first + parts.join(rule.sep);
+    });
+}
+/** True when `value` is a full absolute URL with the scheme `https`. */
+export function isAbsoluteHttpsUrl(value) {
+    return isFullAbsoluteUrl(value) && /^https:/i.test(value);
+}
+/** True when `value` is a full absolute URL with the scheme `http` or `https`. */
+export function isAbsoluteHttpUrl(value) {
+    return isFullAbsoluteUrl(value) && /^https?:/i.test(value);
+}
+/**
+ * The problem with an Offer's `checkoutPageURLTemplate`, if any: the
+ * first of syntax, undefined variables, and the expansion with
+ * `quantity` set to 1 not being an absolute https URL.
+ */
+export function checkoutTemplateProblem(value) {
+    if (typeof value !== "string")
+        return { kind: "not-string" };
+    const parsed = parseTemplate(value);
+    if ("detail" in parsed)
+        return { kind: "invalid", detail: parsed.detail };
+    const undefinedVariables = parsed.variables.filter((v) => !DEFINED_VARIABLES.includes(v));
+    if (undefinedVariables.length > 0)
+        return { kind: "undefined-variables", variables: undefinedVariables };
+    const expansion = expandTemplate(value, { quantity: "1" });
+    return isAbsoluteHttpsUrl(expansion) ? null : { kind: "not-https", expansion };
+}
+/** Whether a region property is present and not empty or whitespace-only. */
+export function declaresRegion(offer) {
+    return ["areaServed", "eligibleRegion"].some((key) => {
+        const value = own(offer, key);
+        if (typeof value === "string")
+            return value.trim().length > 0;
+        if (Array.isArray(value))
+            return value.length > 0;
+        const obj = asObject(value);
+        return obj !== null && Object.keys(obj).length > 0;
+    });
+}

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

@@ -0,0 +1,11 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * COL-E-001 — Member entry without `@id`.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * `@id` is the identity every reference to a set or a product carries
+ * and is matched by exact string, so a `hasPart` or `isPartOf` entry
+ * without one names nothing a consumer can recognise. One finding per
+ * entry, at the entry's path.
+ */
+export declare const colE001: Rule;

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

@@ -0,0 +1,31 @@
+import { entryName, matchedField, memberEntries, nonBlank } from "./col-shared.js";
+/**
+ * COL-E-001 — Member entry without `@id`.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * `@id` is the identity every reference to a set or a product carries
+ * and is matched by exact string, so a `hasPart` or `isPartOf` entry
+ * without one names nothing a consumer can recognise. One finding per
+ * entry, at the entry's path.
+ */
+export const colE001 = {
+    id: "COL-E-001",
+    title: "Member entry without @id",
+    severity: "error",
+    target: "$.data['hasPart','isPartOf']",
+    check: (match) => {
+        const field = matchedField(match.path);
+        const hits = [];
+        for (const { entry, path } of memberEntries(match.value, match.path)) {
+            if (nonBlank(entry["@id"]))
+                continue;
+            hits.push({ path, values: { name: entryName(entry), field } });
+        }
+        return hits;
+    },
+    messageTemplate: "Entry `{name}` at `{path}` in `{field}` carries no `@id`.",
+    remediation: "Add `@id`, the exact `@id` string the member or parent declares in its own sheet. An entry that cannot name its target's identity does not belong in the array.",
+    introduced: "release 0.5.0",
+    appliesFrom: "0.5.0",
+    specReference: "collection.md#members",
+};

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

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

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

@@ -0,0 +1,37 @@
+import { asRecord, COLLECTION_KINDS } from "./col-shared.js";
+/**
+ * COL-E-002 — Collection kind absent or outside the enum.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * `pagefront:collectionKind` is the required, single-valued kind
+ * discriminator; without it a consumer cannot tell whether it is
+ * walking a tree or reading a list. The finding sits at the field when
+ * it is present and at the data block when it is absent.
+ */
+const ENUM_TEXT = COLLECTION_KINDS.map((k) => `\`${k}\``).join(", ");
+export const colE002 = {
+    id: "COL-E-002",
+    title: "Collection kind absent or outside the enum",
+    severity: "error",
+    target: "$.data",
+    check: (match) => {
+        const data = asRecord(match.value);
+        if (data === null)
+            return null;
+        const kind = data["pagefront:collectionKind"];
+        if (kind === undefined)
+            return { values: { problem: "absent" } };
+        if (typeof kind === "string" && COLLECTION_KINDS.includes(kind))
+            return null;
+        const rendered = typeof kind === "string" ? kind : JSON.stringify(kind);
+        return {
+            path: `${match.path}['pagefront:collectionKind']`,
+            values: { problem: `\`${rendered}\`, which is not one of ${ENUM_TEXT}` },
+        };
+    },
+    messageTemplate: "`pagefront:collectionKind` at `{path}` is {problem}.",
+    remediation: "Declare `pagefront:collectionKind` as `category` (a node of the storefront's navigation tree), `collection` (a set outside the tree) or `brand` (the products sold under one label). Additional values require a spec amendment.",
+    introduced: "release 0.5.0",
+    appliesFrom: "0.5.0",
+    specReference: "collection.md#kind-discriminator-pagefrontcollectionkind",
+};

package/dist/rules/col-e-003.d.ts

@@ -0,0 +1,11 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * COL-E-003 — Release / schema mismatch.
+ * The collection-sheet counterpart of PDP-E-002 and ORG-E-003.
+ * Transcribed from commerce/spec/rules.md (normative); the check is
+ * shared (release-schema.ts).
+ *
+ * The Collection Sheet spec has no legacy draft line, so the rule does
+ * not run on legacy sheets.
+ */
+export declare const colE003: Rule;

package/dist/rules/col-e-003.js

@@ -0,0 +1,18 @@
+import { RELEASE_SCHEMA_MISMATCH, releaseSchemaMismatch } from "./release-schema.js";
+/**
+ * COL-E-003 — Release / schema mismatch.
+ * The collection-sheet counterpart of PDP-E-002 and ORG-E-003.
+ * Transcribed from commerce/spec/rules.md (normative); the check is
+ * shared (release-schema.ts).
+ *
+ * The Collection Sheet spec has no legacy draft line, so the rule does
+ * not run on legacy sheets.
+ */
+export const colE003 = {
+    id: "COL-E-003",
+    ...RELEASE_SCHEMA_MISMATCH,
+    check: releaseSchemaMismatch("collection"),
+    introduced: "release 0.5.0",
+    appliesFrom: "0.5.0",
+    specReference: "collection.md#the-envelope",
+};

package/dist/rules/col-e-004.d.ts

@@ -0,0 +1,12 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * COL-E-004 — Unknown release.
+ * The collection-sheet counterpart of PDP-E-018 and ORG-E-004.
+ * Transcribed from commerce/spec/rules.md (normative); the check is
+ * shared (release-schema.ts).
+ *
+ * `appliesFrom` is "0.0.0": the rule judges the declared release
+ * itself, so it cannot be gated by it. It never fires on a sheet of a
+ * published release.
+ */
+export declare const colE004: Rule;