@authorizedretailers/spec 0.1.1 → 0.2.0

package/dist/validate.js

@@ -1,10 +1,14 @@
 import { Validator } from "@cfworker/json-schema";
-import { common, file, fileFull, filePointer, filePrivate, verifyRequest, verifyResponse } from "./schemas.js";
-import { MAX_ANSWER_VALIDITY_MS, MAX_EXPIRY_MS } from "./constants.js";
+import { common, list, pointer, revocationFeed, verifyRequest, verifyResponse } from "./schemas.js";
+import { MAX_STALE_MS, MAX_VALIDITY_MS, MARKETPLACE_DOMAINS } from "./constants.js";
+import { isCountryCode, isMarketplaceDomain, isRecord, normalizeDomain, territoryForDomain } from "./identity.js";
+import { isValidAsin, isValidGtin, toGtin14 } from "./product.js";
 import { parseTimestamp } from "./timestamp.js";
-const ALL_SCHEMAS = [common, fileFull, filePointer, filePrivate, file, verifyRequest, verifyResponse];
-const scopeSchema = { $id: "https://authorizedretailers.ai/schemas/0.1/scope.json", $ref: "common.json#/$defs/scope" };
-const channelSchema = { $id: "https://authorizedretailers.ai/schemas/0.1/channel.json", $ref: "common.json#/$defs/channel" };
+const V = "https://authorizedretailers.ai/schemas/0.2";
+const ALL_SCHEMAS = [common, pointer, list, verifyRequest, verifyResponse, revocationFeed];
+const scopeSchema = { $id: `${V}/scope.json`, $ref: "common.json#/$defs/scope" };
+const channelSchema = { $id: `${V}/channel.json`, $ref: "common.json#/$defs/channel" };
+const productSchema = { $id: `${V}/product.json`, $ref: "common.json#/$defs/product" };
 function makeValidator(root) {
     const v = new Validator(root, "2020-12", false);
     for (const s of ALL_SCHEMAS)
@@ -39,136 +43,325 @@ function dedupe(errors) {
         return true;
     });
 }
-function done(errors, value) {
-    return errors.length === 0 ? { valid: true, value: value, errors: [] } : { valid: false, errors };
+class Report {
+    errors = [];
+    warnings = [];
+    /** Paths a specific error already explains; schema errors under them only repeat it. */
+    claimed = [];
+    error(code, path, message) {
+        this.errors.push({ code, path, message });
+    }
+    warn(code, path, message) {
+        this.warnings.push({ code, path, message });
+    }
+    done(value) {
+        return this.errors.length === 0
+            ? { valid: true, value: value, errors: [], warnings: this.warnings }
+            : { valid: false, errors: this.errors, warnings: this.warnings };
+    }
 }
-function ts(errors, path, value) {
+function ts(r, path, value) {
     const ms = parseTimestamp(value);
     if (ms === null)
-        errors.push({ code: "invalid_timestamp", path, message: `not a valid UTC timestamp: ${value}` });
+        r.error("invalid_timestamp", path, `not a valid UTC timestamp: ${value}`);
     return ms;
 }
-const ONLINE_CHANNEL_TYPES = new Set(["amazon", "walmart", "ebay", "web"]);
+const CHANNEL_TYPES = new Set(["amazon", "walmart", "ebay", "web"]);
 /**
- * Section 6: every authorization MUST name at least one online channel identifier. The schema
- * enforces this too (`contains`), but its error is buried in generic output, so name it plainly.
- * Runs on unvalidated input, so it checks shapes defensively.
+ * Section 6 rules on one channel that the generic schema output would bury: removed fields and
+ * types, and marketplace domains that don't match the type. Runs on unvalidated input.
  */
-function onlineChannelErrors(input) {
-    const auths = input?.authorizations;
-    if (!Array.isArray(auths))
-        return [];
-    const errors = [];
-    auths.forEach((a, i) => {
-        const channels = a?.channels;
-        if (!Array.isArray(channels) || channels.length === 0)
-            return;
-        const online = channels.some((c) => ONLINE_CHANNEL_TYPES.has(c?.type));
-        if (!online) {
-            errors.push({
-                code: "no_online_channel",
-                path: `/authorizations/${i}/channels`,
-                message: "an authorization MUST name at least one online channel identifier (amazon, walmart, ebay or web); a physical identifier alone does not authorize anything (section 6)",
-            });
-        }
-    });
-    return errors;
-}
-/** Rules the JSON Schema cannot express (sections 5 and 10). Assumes the file already passed the schema. */
-function fullFileRules(f) {
-    const errors = [];
-    const issued = ts(errors, "/issued", f.issued);
-    const expires = ts(errors, "/expires", f.expires);
-    if (issued !== null && expires !== null) {
-        if (expires <= issued) {
-            errors.push({ code: "expires_not_after_issued", path: "/expires", message: "file expires must be after issued" });
+function channelRules(r, path, input) {
+    if (!isRecord(input))
+        return;
+    const before = r.errors.length;
+    channelChecks(r, path, input);
+    if (r.errors.length > before)
+        r.claimed.push(path);
+}
+function channelChecks(r, path, input) {
+    const type = input.type;
+    if (typeof type === "string" && !CHANNEL_TYPES.has(type)) {
+        r.error("unknown_channel_type", path, `unknown channel type "${type}"; v0.2 has amazon, walmart, ebay and web (section 6)`);
+        return;
+    }
+    if ("marketplace" in input) {
+        r.error("marketplace_field_removed", `${path}/marketplace`, 'the "marketplace" field was removed in v0.2: identify the marketplace by "domain", e.g. "amazon.com" (section 6)');
+    }
+    if (typeof input.domain !== "string")
+        return;
+    const domain = normalizeDomain(input.domain);
+    if (type === "web") {
+        if (isMarketplaceDomain(domain)) {
+            r.error("marketplace_domain_mismatch", `${path}/domain`, `${domain} is a marketplace domain; list the seller as a ${MARKETPLACE_DOMAINS[domain].type} channel (section 6)`);
         }
-        else if (expires - issued > MAX_EXPIRY_MS) {
-            errors.push({
-                code: "file_expiry_exceeds_max",
-                path: "/expires",
-                message: "file expires more than 180 days after issued (section 10)",
-            });
+    }
+    else if (typeof type === "string") {
+        const market = MARKETPLACE_DOMAINS[domain];
+        if (!market || market.type !== type) {
+            r.error("marketplace_domain_mismatch", `${path}/domain`, `${domain} is not one of the ${type} marketplace domains (section 6)`);
         }
     }
-    const ids = new Set();
-    f.authorizations.forEach((a, i) => {
-        const base = `/authorizations/${i}`;
-        if (ids.has(a.id)) {
-            errors.push({ code: "duplicate_authorization_id", path: `${base}/id`, message: `duplicate authorization id ${a.id}` });
+}
+/** Territory codes must be ISO 3166-1 alpha-2 (UK is GB). The schema enforces this too; name it plainly. */
+function countryRule(r, path, value) {
+    if (typeof value === "string" && value !== "*" && !isCountryCode(value)) {
+        r.error("invalid_country", path, `${value} is not an ISO 3166-1 alpha-2 code${value.toUpperCase() === "UK" ? " (the United Kingdom is GB)" : ""}`);
+    }
+}
+/** Section 6.2 territory rules for one authorization. Assumes the list passed the schema. */
+function territoryRules(r, base, channels, scope) {
+    const listed = scope.territories;
+    const worldwide = listed?.[0] === "*";
+    channels.forEach((c, j) => {
+        const own = territoryForDomain(c.domain);
+        const path = `${base}/channels/${j}`;
+        if (c.type !== "web") {
+            if (listed && !worldwide && own !== null && !listed.includes(own)) {
+                r.error("territory_mismatch", `${base}/scope/territories`, `${c.domain} is in ${own}, which scope.territories leaves out (section 6.2)`);
+            }
         }
-        ids.add(a.id);
-        const aExpires = ts(errors, `${base}/expires`, a.expires);
-        if (aExpires !== null && expires !== null && aExpires > expires) {
-            errors.push({
-                code: "authorization_expires_after_file",
-                path: `${base}/expires`,
-                message: "an authorization's expires MUST NOT be later than the file's expires (section 5)",
-            });
+        else if (own === null) {
+            if (!listed)
+                r.error("territories_required", path, `${c.domain} is a generic domain, so the authorization must list scope.territories (section 6.2)`);
+        }
+        else if (listed && !worldwide && !listed.includes(own)) {
+            r.warn("territory_differs_from_domain", `${base}/scope/territories`, `${c.domain} is a ${own} domain but the territories listed leave out ${own}`);
         }
     });
-    return errors;
-}
-function verifyResponseRules(r) {
-    const errors = [];
-    const checked = ts(errors, "/checked", r.checked);
-    const validUntil = ts(errors, "/valid_until", r.valid_until);
-    if ("expires" in r)
-        ts(errors, "/expires", r.expires);
-    for (const [i, s] of r.signals.entries())
-        ts(errors, `/signals/${i}/observed`, s.observed);
-    if (r.observed)
-        ts(errors, "/observed/last_seen", r.observed.last_seen);
-    if (checked !== null && validUntil !== null) {
-        if (validUntil <= checked) {
-            errors.push({ code: "valid_until_not_after_checked", path: "/valid_until", message: "valid_until must be after checked" });
+}
+/** Section 3.1 catalog rules. Assumes the list passed the schema. */
+function catalogRules(r, l) {
+    const catalog = l.catalog ?? [];
+    const ids = new Set();
+    const lines = new Set();
+    const identifiers = new Map();
+    catalog.forEach((p, i) => {
+        const base = `/catalog/${i}`;
+        if (ids.has(p.id))
+            r.error("duplicate_product_id", `${base}/id`, `duplicate product id ${p.id}`);
+        ids.add(p.id);
+        if (p.product_line)
+            lines.add(p.product_line);
+        const claim = (key, path, shown) => {
+            const other = identifiers.get(key);
+            if (other !== undefined && other !== p.id)
+                r.error("duplicate_identifier", path, `${shown} is on products ${other} and ${p.id}`);
+            identifiers.set(key, p.id);
+        };
+        if (p.gtin !== undefined) {
+            if (!isValidGtin(p.gtin))
+                r.error("invalid_gtin", `${base}/gtin`, `${p.gtin} is not a valid GTIN (bad length or check digit)`);
+            else
+                claim(`gtin:${toGtin14(p.gtin)}`, `${base}/gtin`, `GTIN ${p.gtin}`);
+        }
+        p.asins?.forEach((a, j) => claim(`asin:${a}`, `${base}/asins/${j}`, `ASIN ${a}`));
+    });
+    const hasCatalog = catalog.length > 0;
+    const checkLines = (names, path) => names?.forEach((n, k) => {
+        if (n === "all")
+            return;
+        if (hasCatalog && !lines.has(n))
+            r.error("unknown_product_line", `${path}/${k}`, `product line "${n}" is not in the catalog (section 3.1)`);
+    });
+    const checkExclusionLines = (names, path) => names?.forEach((n, k) => {
+        if (!lines.has(n))
+            r.error("unknown_product_line", `${path}/${k}`, `excluded product line "${n}" is not in the catalog (section 3.1)`);
+    });
+    const checkProducts = (list, path) => list?.forEach((id, k) => {
+        if (!ids.has(id))
+            r.error("unknown_product", `${path}/${k}`, `product ${id} is not in the catalog (section 3.1)`);
+    });
+    checkExclusionLines(l.exclusions?.product_lines, "/exclusions/product_lines");
+    checkProducts(l.exclusions?.products, "/exclusions/products");
+    l.authorizations.forEach((a, i) => {
+        const base = `/authorizations/${i}/scope`;
+        checkLines(a.scope.product_lines, `${base}/product_lines`);
+        checkExclusionLines(a.scope.exclude_product_lines, `${base}/exclude_product_lines`);
+        checkProducts(a.scope.products, `${base}/products`);
+        checkProducts(a.scope.exclude_products, `${base}/exclude_products`);
+    });
+}
+/** Section 3.1: each product has a gtin or asins. Named plainly, since the schema's anyOf error is vague. */
+function productIdentifierRules(r, input) {
+    const catalog = isRecord(input) ? input.catalog : undefined;
+    if (!Array.isArray(catalog))
+        return;
+    catalog.forEach((p, i) => {
+        if (isRecord(p) && !("gtin" in p) && !("asins" in p)) {
+            r.error("product_without_identifier", `/catalog/${i}`, "every product needs a gtin or at least one ASIN (section 3.1)");
         }
-        else if (validUntil - checked > MAX_ANSWER_VALIDITY_MS) {
-            errors.push({
-                code: "valid_until_exceeds_max",
-                path: "/valid_until",
-                message: "valid_until MUST be no later than 24 hours after checked (section 9)",
+        if (isRecord(p) && Array.isArray(p.asins)) {
+            p.asins.forEach((a, j) => {
+                if (typeof a === "string" && !isValidAsin(a))
+                    r.error("invalid_asin", `/catalog/${i}/asins/${j}`, `${a} is not an ASIN (10 uppercase letters or digits)`);
             });
         }
-    }
-    return errors;
+    });
+}
+/** Section 10: valid_until within 15 minutes of issue, stale_until within 24 hours and not before valid_until. */
+function freshnessRules(r, issuedAt, issuedPath, doc) {
+    const issued = ts(r, issuedPath, issuedAt);
+    const validUntil = ts(r, "/valid_until", doc.valid_until);
+    const staleUntil = ts(r, "/stale_until", doc.stale_until);
+    if (issued === null || validUntil === null || staleUntil === null)
+        return;
+    if (validUntil <= issued)
+        r.error("valid_until_not_after_issued", "/valid_until", `valid_until must be after ${issuedPath.slice(1)}`);
+    else if (validUntil - issued > MAX_VALIDITY_MS)
+        r.error("valid_until_exceeds_max", "/valid_until", "valid_until MUST be no later than 15 minutes after issue (section 10.1)");
+    if (staleUntil < validUntil)
+        r.error("stale_until_before_valid_until", "/stale_until", "stale_until must not be before valid_until");
+    else if (staleUntil - issued > MAX_STALE_MS)
+        r.error("stale_until_exceeds_max", "/stale_until", "stale_until MUST be no later than 24 hours after issue (section 10.2)");
 }
-/** Validates an authorized-retailers.json file of any form. */
-export function validateFile(input) {
-    const isFull = input?.form === "full";
-    const errors = [...(isFull ? onlineChannelErrors(input) : []), ...schemaErrors(file, input)];
-    if (errors.length === 0 && input.form === "full") {
-        errors.push(...fullFileRules(input));
+/** Walks the channels in an unvalidated list or request, applying channelRules and countryRule. */
+function preSchemaChecks(r, input) {
+    if (!isRecord(input))
+        return;
+    if (isRecord(input.channel))
+        channelRules(r, "/channel", input.channel);
+    countryRule(r, "/territory", input.territory);
+    if (Array.isArray(input.authorizations)) {
+        input.authorizations.forEach((a, i) => {
+            if (!isRecord(a))
+                return;
+            if (Array.isArray(a.channels))
+                a.channels.forEach((c, j) => channelRules(r, `/authorizations/${i}/channels/${j}`, c));
+            if (isRecord(a.scope) && Array.isArray(a.scope.territories)) {
+                a.scope.territories.forEach((t, k) => countryRule(r, `/authorizations/${i}/scope/territories/${k}`, t));
+            }
+        });
     }
-    return done(errors, input);
+    productIdentifierRules(r, input);
 }
-export function validateFullFile(input) {
-    const errors = [...onlineChannelErrors(input), ...schemaErrors(fileFull, input)];
-    if (errors.length === 0)
-        errors.push(...fullFileRules(input));
-    return done(errors, input);
+/** Keeps the specific errors and drops schema errors at or under the same paths, which only repeat them. */
+function merge(r, schema) {
+    const specific = [...r.errors.map((e) => e.path), ...r.claimed];
+    for (const e of schema) {
+        if (!specific.some((p) => e.path === p || e.path.startsWith(`${p}/`) || p.startsWith(`${e.path}/`)))
+            r.errors.push(e);
+    }
 }
-export function validatePointerFile(input) {
-    return done(schemaErrors(filePointer, input), input);
+/**
+ * Validates a pointer file (section 5.1). Pass the domain it was fetched from (the domain first
+ * asked for, before any redirects) to check that the pointer vouches for it.
+ */
+export function validateFile(input, fetchedFrom) {
+    const r = new Report();
+    const form = isRecord(input) ? input.form : undefined;
+    if (form !== "pointer") {
+        r.error("form_not_supported", "/form", `form ${JSON.stringify(form)} is not supported; v0.2 has only "pointer" (section 5.1)`);
+        return r.done(input);
+    }
+    const list = input.list;
+    if (typeof list === "string" && /^https:\/\//.test(list) && !list.startsWith("https://authorizedretailers.ai/")) {
+        r.error("list_not_on_registry", "/list", "the list MUST be an https://authorizedretailers.ai/ URL; a pointer to any other host is no file (section 5.1)");
+    }
+    const brand = input.brand;
+    if (fetchedFrom !== undefined && typeof brand?.domain === "string" && normalizeDomain(brand.domain) !== normalizeDomain(fetchedFrom)) {
+        r.error("brand_domain_mismatch", "/brand/domain", `the pointer names ${brand.domain} but was fetched from ${fetchedFrom}; a pointer vouches only for its own domain (section 5.1)`);
+    }
+    merge(r, schemaErrors(pointer, input));
+    return r.done(input);
 }
-export function validatePrivateFile(input) {
-    return done(schemaErrors(filePrivate, input), input);
+/** Validates a signed list or not-public response (section 5.2). Does not check the signature: see checkPublishedList. */
+export function validateList(input) {
+    const r = new Report();
+    preSchemaChecks(r, input);
+    merge(r, schemaErrors(list, input));
+    if (r.errors.length === 0) {
+        const l = input;
+        freshnessRules(r, l.issued, "/issued", l);
+        if (l.public) {
+            const ids = new Set();
+            l.authorizations.forEach((a, i) => {
+                const base = `/authorizations/${i}`;
+                if (ids.has(a.id))
+                    r.error("duplicate_authorization_id", `${base}/id`, `duplicate authorization id ${a.id}`);
+                ids.add(a.id);
+                if (a.expires !== undefined)
+                    ts(r, `${base}/expires`, a.expires);
+                territoryRules(r, base, a.channels, a.scope);
+            });
+            catalogRules(r, l);
+        }
+    }
+    return r.done(input);
 }
 /** Validates a canonical verify request. Call normalizeVerifyRequest on raw agent input first. */
 export function validateVerifyRequest(input) {
-    return done(schemaErrors(verifyRequest, input), input);
+    const r = new Report();
+    preSchemaChecks(r, input);
+    const product = isRecord(input) && isRecord(input.product) ? input.product : undefined;
+    if (typeof product?.gtin === "string" && /^(\d{8}|\d{12,14})$/.test(product.gtin) && !isValidGtin(product.gtin)) {
+        r.error("invalid_gtin", "/product/gtin", `${product.gtin} has a bad check digit`);
+    }
+    if (typeof product?.asin === "string" && !isValidAsin(product.asin)) {
+        r.error("invalid_asin", "/product/asin", `${product.asin} is not an ASIN (10 uppercase letters or digits)`);
+    }
+    merge(r, schemaErrors(verifyRequest, input));
+    if (r.errors.length === 0) {
+        const req = input;
+        if (req.territory === undefined && territoryForDomain(req.channel.domain) === null) {
+            r.error("territory_required", "/territory", `${req.channel.domain} is a generic domain, so the request must name a territory (section 6.2)`);
+        }
+        if (req.as_of !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(req.as_of))
+            ts(r, "/as_of", req.as_of);
+    }
+    return r.done(input);
 }
 export function validateVerifyResponse(input) {
-    const errors = schemaErrors(verifyResponse, input);
-    if (errors.length === 0)
-        errors.push(...verifyResponseRules(input));
-    return done(errors, input);
+    const r = new Report();
+    merge(r, schemaErrors(verifyResponse, input));
+    if (r.errors.length === 0) {
+        const res = input;
+        freshnessRules(r, res.checked, "/checked", res);
+        if ("expires" in res && res.expires !== undefined)
+            ts(r, "/expires", res.expires);
+        if (res.as_of !== undefined)
+            ts(r, "/as_of", res.as_of);
+        for (const [i, s] of res.signals.entries())
+            ts(r, `/signals/${i}/observed`, s.observed);
+        if (res.observed)
+            ts(r, "/observed/last_seen", res.observed.last_seen);
+    }
+    return r.done(input);
+}
+/** Validates a revocation feed (section 10.3). Does not check the signature: see checkRevocationFeed. */
+export function validateRevocationFeed(input) {
+    const r = new Report();
+    merge(r, schemaErrors(revocationFeed, input));
+    if (r.errors.length === 0) {
+        const f = input;
+        freshnessRules(r, f.issued, "/issued", f);
+        f.entries.forEach((e, i) => ts(r, `/entries/${i}/revoked`, e.revoked));
+    }
+    return r.done(input);
 }
-/** Validates one authorization scope (§3), e.g. before a registry stores it. */
+/** Validates one authorization scope (section 3), e.g. before the registry stores it. */
 export function validateScope(input) {
-    return done(schemaErrors(scopeSchema, input), input);
+    const r = new Report();
+    if (isRecord(input) && Array.isArray(input.territories))
+        input.territories.forEach((t, k) => countryRule(r, `/territories/${k}`, t));
+    merge(r, schemaErrors(scopeSchema, input));
+    return r.done(input);
 }
-/** Validates one channel identifier (§6), e.g. before a registry stores it. */
+/** Validates one channel identifier (section 6), e.g. before the registry stores it. */
 export function validateChannel(input) {
-    return done(schemaErrors(channelSchema, input), input);
+    const r = new Report();
+    channelRules(r, "", input);
+    merge(r, schemaErrors(channelSchema, input));
+    return r.done(input);
+}
+/** Validates one catalog product (section 3.1), e.g. a row from a brand's CSV import. */
+export function validateProduct(input) {
+    const r = new Report();
+    productIdentifierRules(r, { catalog: [input] });
+    r.errors.forEach((e) => (e.path = e.path.replace(/^\/catalog\/0/, "")));
+    if (isRecord(input) && typeof input.gtin === "string" && /^(\d{8}|\d{12,14})$/.test(input.gtin) && !isValidGtin(input.gtin)) {
+        r.error("invalid_gtin", "/gtin", `${input.gtin} has a bad check digit`);
+    }
+    merge(r, schemaErrors(productSchema, input));
+    return r.done(input);
 }

package/fixtures/list/invalid/list-all-mixed.json

@@ -0,0 +1,53 @@
+{
+  "spec": "authorized-retailers/0.2",
+  "brand": {
+    "name": "Example Brand",
+    "domains": [
+      "brand.example"
+    ]
+  },
+  "public": true,
+  "issued": "2026-09-28T14:00:00Z",
+  "valid_until": "2026-09-28T14:15:00Z",
+  "stale_until": "2026-09-29T14:00:00Z",
+  "authorizations": [
+    {
+      "id": "auth_01J9X2",
+      "revocation_id": "rv_Q2l8dX4bT0aN5kPw",
+      "retailer": {
+        "name": "Example Retail LLC",
+        "entity_id": "ent_7Q4M"
+      },
+      "channels": [
+        {
+          "type": "amazon",
+          "domain": "amazon.com",
+          "seller_id": "A1B2C3D4E5F6G7"
+        },
+        {
+          "type": "walmart",
+          "domain": "walmart.com",
+          "seller_id": "101234567"
+        },
+        {
+          "type": "web",
+          "domain": "retailer.example"
+        }
+      ],
+      "scope": {
+        "territories": [
+          "US"
+        ],
+        "product_lines": [
+          "all",
+          "Running"
+        ]
+      },
+      "proposed_by": null
+    }
+  ],
+  "signature": {
+    "kid": "ar-20260928-6e37",
+    "jws": "eyJhbGciOiJFZERTQSIsImtpZCI6ImFyLTIwMjYwOTI4LTZlMzcifQ..c2lnbmF0dXJlLXBsYWNlaG9sZGVy"
+  }
+}

package/fixtures/list/invalid/list-amazon-missing-seller-id.json

@@ -0,0 +1,51 @@
+{
+  "spec": "authorized-retailers/0.2",
+  "brand": {
+    "name": "Example Brand",
+    "domains": [
+      "brand.example"
+    ]
+  },
+  "public": true,
+  "issued": "2026-09-28T14:00:00Z",
+  "valid_until": "2026-09-28T14:15:00Z",
+  "stale_until": "2026-09-29T14:00:00Z",
+  "authorizations": [
+    {
+      "id": "auth_01J9X2",
+      "revocation_id": "rv_Q2l8dX4bT0aN5kPw",
+      "retailer": {
+        "name": "Example Retail LLC",
+        "entity_id": "ent_7Q4M"
+      },
+      "channels": [
+        {
+          "type": "amazon",
+          "domain": "amazon.com"
+        },
+        {
+          "type": "walmart",
+          "domain": "walmart.com",
+          "seller_id": "101234567"
+        },
+        {
+          "type": "web",
+          "domain": "retailer.example"
+        }
+      ],
+      "scope": {
+        "territories": [
+          "US"
+        ],
+        "product_lines": [
+          "all"
+        ]
+      },
+      "proposed_by": null
+    }
+  ],
+  "signature": {
+    "kid": "ar-20260928-6e37",
+    "jws": "eyJhbGciOiJFZERTQSIsImtpZCI6ImFyLTIwMjYwOTI4LTZlMzcifQ..c2lnbmF0dXJlLXBsYWNlaG9sZGVy"
+  }
+}

package/fixtures/list/invalid/list-amazon-on-walmart-domain.json

@@ -0,0 +1,52 @@
+{
+  "spec": "authorized-retailers/0.2",
+  "brand": {
+    "name": "Example Brand",
+    "domains": [
+      "brand.example"
+    ]
+  },
+  "public": true,
+  "issued": "2026-09-28T14:00:00Z",
+  "valid_until": "2026-09-28T14:15:00Z",
+  "stale_until": "2026-09-29T14:00:00Z",
+  "authorizations": [
+    {
+      "id": "auth_01J9X2",
+      "revocation_id": "rv_Q2l8dX4bT0aN5kPw",
+      "retailer": {
+        "name": "Example Retail LLC",
+        "entity_id": "ent_7Q4M"
+      },
+      "channels": [
+        {
+          "type": "amazon",
+          "domain": "walmart.com",
+          "seller_id": "A1B2C3D4E5F6G7"
+        },
+        {
+          "type": "walmart",
+          "domain": "walmart.com",
+          "seller_id": "101234567"
+        },
+        {
+          "type": "web",
+          "domain": "retailer.example"
+        }
+      ],
+      "scope": {
+        "territories": [
+          "US"
+        ],
+        "product_lines": [
+          "all"
+        ]
+      },
+      "proposed_by": null
+    }
+  ],
+  "signature": {
+    "kid": "ar-20260928-6e37",
+    "jws": "eyJhbGciOiJFZERTQSIsImtpZCI6ImFyLTIwMjYwOTI4LTZlMzcifQ..c2lnbmF0dXJlLXBsYWNlaG9sZGVy"
+  }
+}