diff --git a/.cspell.json b/.cspell.json index dc09c20..86871ce 100644 --- a/.cspell.json +++ b/.cspell.json @@ -11,7 +11,8 @@ ".cspell.json", "**/*.svg", ".gitignore", - "package.json" + "package.json", + "requirements/catalog/**" ], "dictionaryDefinitions": [ { diff --git a/.cspell/custom-words.txt b/.cspell/custom-words.txt index 7ac7c1a..ad93bd6 100644 --- a/.cspell/custom-words.txt +++ b/.cspell/custom-words.txt @@ -1,6 +1,7 @@ # cspell-specific custom words related to UCP absl absltest +addoption adyen Adyen agentic @@ -9,6 +10,7 @@ Amex Ant Anytown atok +autojunk backorder Backordered Braintree @@ -32,17 +34,20 @@ flagsaver Flipkart fontawesome fpan +getoption fulfillable Gap GitHub Google gpay Gpay +gpgsign healthz idless ingestions inlinehilite Kroger +levelname linenums llmstxt Lowe's @@ -51,13 +56,16 @@ Malform mastercard Mastercard mkdocs +modifyitems mtok +nodeid openapi openrpc Paymentech paypal Paypal permissionless +pluginmanager preorders Preorders proto @@ -78,6 +86,7 @@ Smallville Stripe superfences Target +terminalreporter testpaths UCP Ulta diff --git a/.gitignore b/.gitignore index 1ebcbb4..6a9c856 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ uv.lock .venv node_modules/ +requirements/reports/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index d653dcf..ed496ff 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -37,6 +37,9 @@ repos: hooks: - id: prettier files: \.(json|md|yaml|yml)$ + # requirements/tools/build_catalog.py writes the catalog, and its + # output must stay byte-identical to what the tool produces. + exclude: ^requirements/catalog/ - repo: https://github.com/koalaman/shellcheck-precommit rev: v0.10.0 hooks: @@ -46,3 +49,5 @@ repos: rev: v2.4.1 hooks: - id: codespell + # The catalog quotes the specification verbatim. + exclude: ^requirements/catalog/ diff --git a/conftest.py b/conftest.py index 892d262..0f0a7e9 100644 --- a/conftest.py +++ b/conftest.py @@ -14,7 +14,41 @@ """Configuration file for pytest.""" +import pytest + +from framework import marker_check from framework.base_test import FLAGS FLAGS(["pytest"]) + + +def pytest_addoption(parser: pytest.Parser) -> None: + """Add the option for the requirements check.""" + parser.addoption( + "--requirements-check", + choices=marker_check.MODES, + default="strict", + help="check the shopping tests' spec markers against the requirements " + "catalog: strict stops on problems, warn only reports them, off skips the " + "check (default: strict)", + ) + + +def pytest_collection_modifyitems( + config: pytest.Config, items: list[pytest.Item] +) -> None: + """Check the spec markers of the collected tests, as the runner does.""" + report, stop = marker_check.evaluate( + [marker_check.from_pytest_item(item) for item in items], + config.getoption("--requirements-check"), + ) + reporter = config.pluginmanager.get_plugin("terminalreporter") + if report and reporter is not None: + reporter.ensure_newline() + reporter.write(report) + if stop: + raise pytest.UsageError( + "requirements check failed: fix the problems above, or pass " + "--requirements-check=warn to run anyway" + ) diff --git a/framework/__init__.py b/framework/__init__.py index 6aff1bd..38cb19d 100644 --- a/framework/__init__.py +++ b/framework/__init__.py @@ -16,7 +16,15 @@ from framework.agent_profile_server import AgentProfileServer from framework.base_test import BaseIntegrationTest -from framework.decorators import requires_capability, spec_assert +from framework.decorators import ( + no_rule, + older_version, + outside_catalog, + partly, + requires_capability, + scenario, + spec_assert, +) from framework.discovery import Capability, UcpProfile, fetch_server_profile from framework.mock_webhook_server import MockWebhookServer from framework.platform import PlatformProfile, PlatformRequirement @@ -30,6 +38,11 @@ "PlatformRequirement", "UcpProfile", "fetch_server_profile", + "no_rule", + "older_version", + "outside_catalog", + "partly", "requires_capability", + "scenario", "spec_assert", ] diff --git a/framework/decorators.py b/framework/decorators.py index 7e2f7c1..83c0255 100644 --- a/framework/decorators.py +++ b/framework/decorators.py @@ -15,11 +15,28 @@ """Decorators for capability filtering and specification traceability.""" from collections.abc import Callable -import functools +import dataclasses +import inspect +import re from typing import TypeVar +import unittest + +from framework.requirements import ID_RE T = TypeVar("T") +# Where a marker is kept on the test method it labels. +MARKER_ATTRIBUTE = "_spec_marker" +MARKER_KINDS = ( + "spec_assert", + "no_rule", + "scenario", + "outside_catalog", + "older_version", +) +# UCP versions are release dates. +VERSION_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$") + def requires_capability( capability_name: str, min_version: str | None = None @@ -51,28 +68,248 @@ def decorator(obj: T) -> T: return decorator -def spec_assert(section: str, requirement_id: str) -> Callable: - """Tag a test method with a specific clause from the UCP specification. +@dataclasses.dataclass(frozen=True) +class SpecMarker: + """What a test says about the specification rules it checks. + + Attributes: + kind: One of `MARKER_KINDS`. + rule_ids: For "spec_assert", the IDs of every rule the test cites, those + it checks fully and those it checks only in part, in the order given. + reason: For the other kinds, why the test cites no rule in the catalog. + version: For "older_version", the specification release the test checks. + gaps: For "spec_assert", the rules the test checks only in part, each + with what the test leaves unchecked, in the order given. + + """ + + kind: str + rule_ids: tuple[str, ...] = () + reason: str = "" + version: str = "" + gaps: tuple[tuple[str, str], ...] = () + + @property + def partial_ids(self) -> frozenset[str]: + """Return the IDs of the rules the test checks only in part.""" + return frozenset(rule_id for rule_id, _ in self.gaps) + + +@dataclasses.dataclass(frozen=True) +class PartialClaim: + """A rule a test checks only in part; see `partly`. + + Attributes: + rule_id: The rule's ID. + gap: What the test leaves unchecked. + + """ + + rule_id: str + gap: str + + +def partly(rule_id: str, gap: str) -> PartialClaim: + """Cite a rule the test checks only in part, saying what it leaves out. + + Use it inside `spec_assert`, next to the rules the test checks fully: + + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0134", # exactly one "total" entry + partly( + "REQ-SHOPPING-CHECKOUT-0016", # line total is price x quantity + "whole-number quantities only, so scale and rounding aren't checked", + ), + ) + + The report counts a rule as covered only when some test checks it fully; + a rule cited only this way counts as checked in part, with its gap. + + Args: + rule_id: The rule's ID. + gap: What the test's assertions leave unchecked. + + Returns: + The claim, for `spec_assert`. + + Raises: + ValueError: If the gap is empty. + + """ + return PartialClaim(rule_id, _reason("partly", gap)) + + +def spec_assert(*claims: str | PartialClaim) -> Callable[[T], T]: + """Mark a test as checking one or more specification rules. + + Rules are cited by their stable ID in the requirements catalog, such as + `REQ-SHOPPING-CHECKOUT-0133`. Cite the rules the test's assertions check, + not every rule the test passes through on the way, and wrap a rule the + test checks only in part in `partly`. Like the other markers, this only + labels the test: it runs exactly as before. A test takes one marker. + + Args: + *claims: The IDs of the rules the test checks fully, and `partly` claims + for those it checks only in part. + + Returns: + A decorator for a test method. + + Raises: + ValueError: If no rule is given, or an ID is malformed or given twice. + + """ + if not claims: + raise ValueError("spec_assert needs at least one rule ID") + rule_ids = tuple( + claim.rule_id if isinstance(claim, PartialClaim) else claim + for claim in claims + ) + malformed = [ + rule_id + for rule_id in rule_ids + if not isinstance(rule_id, str) or not ID_RE.match(rule_id) + ] + if malformed: + raise ValueError(f"spec_assert: malformed rule IDs {malformed}") + repeated = sorted( + {rule_id for rule_id in rule_ids if rule_ids.count(rule_id) > 1} + ) + if repeated: + raise ValueError(f"spec_assert: rule IDs given twice {repeated}") + gaps = tuple( + (claim.rule_id, claim.gap) + for claim in claims + if isinstance(claim, PartialClaim) + ) + return _label(SpecMarker("spec_assert", rule_ids=rule_ids, gaps=gaps)) + + +def no_rule(reason: str) -> Callable[[T], T]: + """Mark a test whose behavior the spec describes without a keyword. + + For a test of behavior the specification describes, but not with an + RFC 2119 keyword, so the catalog has no rule for it. + + Args: + reason: Where and how the specification describes the behavior. + + Returns: + A decorator for a test method. + + Raises: + ValueError: If the reason is empty. + + """ + return _label(SpecMarker("no_rule", reason=_reason("no_rule", reason))) + + +def scenario(reason: str) -> Callable[[T], T]: + """Mark a test that checks a store's own data rather than a spec rule. + + For a test built on one store's products or settings, such as a + free-shipping threshold, whose expected outcome no rule decides. + + Args: + reason: What the test checks instead of a rule. + + Returns: + A decorator for a test method. + + Raises: + ValueError: If the reason is empty. + + """ + return _label(SpecMarker("scenario", reason=_reason("scenario", reason))) + + +def outside_catalog(reason: str) -> Callable[[T], T]: + """Mark a test that checks a rule this catalog does not contain. - Used for automated compliance matrix generation and test auditing. + For a test of a rule stated on a specification page the catalog doesn't + cover, such as the core overview page. Once the catalog covers that page, + the test can cite the rule with `spec_assert`. Args: - section: The specification section identifier. - requirement_id: The specific requirement ID. + reason: Which page states the rule, and what the rule is. Returns: - The decorated test method. + A decorator for a test method. + + Raises: + ValueError: If the reason is empty. """ + return _label( + SpecMarker("outside_catalog", reason=_reason("outside_catalog", reason)) + ) + + +def older_version(version: str, reason: str) -> Callable[[T], T]: + """Mark a test that checks an older version of the specification. + + For a test of behavior that the catalog's version of the specification + has changed or dropped. Each such test is one to update. + + Args: + version: The release the test checks, such as "2026-04-08". + reason: What changed since that release. + + Returns: + A decorator for a test method. + + Raises: + ValueError: If the version is not a release date, or the reason is empty. + + """ + if not isinstance(version, str) or not VERSION_RE.match(version): + raise ValueError(f"older_version: {version!r} is not a release date") + return _label( + SpecMarker( + "older_version", + reason=_reason("older_version", reason), + version=version, + ) + ) + + +def spec_marker( + test: Callable[..., object] | unittest.TestCase, +) -> SpecMarker | None: + """Return the marker a test carries, or None if it has none. + + Args: + test: A test method, or a test case as unittest loads it. + + Returns: + The test's marker, or None. + + """ + if isinstance(test, unittest.TestCase): + test = getattr(test, test._testMethodName) + return getattr(test, MARKER_ATTRIBUTE, None) + + +def _reason(kind: str, reason: str) -> str: + """Return a marker's reason, which must not be empty.""" + if not isinstance(reason, str) or not reason.strip(): + raise ValueError(f"{kind} needs a reason") + return reason.strip() - def decorator(func: Callable) -> Callable: - func._spec_section = section - func._spec_requirement_id = requirement_id - @functools.wraps(func) - def wrapper(*args, **kwargs): - return func(*args, **kwargs) +def _label(marker: SpecMarker) -> Callable[[T], T]: + """Return a decorator that attaches a marker to a test method.""" - return wrapper + def decorator(func: T) -> T: + if not inspect.isfunction(func): + raise TypeError(f"{marker.kind} labels a test method, not {func!r}") + earlier = getattr(func, MARKER_ATTRIBUTE, None) + if earlier is not None: + raise ValueError( + f"{func.__qualname__} already has a {earlier.kind} marker; a test " + "takes one marker" + ) + setattr(func, MARKER_ATTRIBUTE, marker) + return func return decorator diff --git a/framework/marker_check.py b/framework/marker_check.py new file mode 100644 index 0000000..2a14210 --- /dev/null +++ b/framework/marker_check.py @@ -0,0 +1,237 @@ +# Copyright 2026 UCP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Check the specification markers of loaded tests against the catalog. + +The check runs once tests are loaded and before any of them runs: from +`runner.py`, including with `--dry-run`, and from pytest through +`conftest.py`. Only the shopping suite has a catalog, so only its tests are +checked. + +Problems stop the run in strict mode: +- a test with no marker; +- a cited ID that is not in the catalog, or that the catalog retired without + a history; +- a cited ID that the review found states no requirement. + +Warnings never stop it: +- a cited rule that only older releases state, which the catalog keeps as a + removed rule; +- a cited rule that this suite cannot test; +- a cited rule outside the capabilities the test requires. +""" + +import collections +from collections.abc import Iterable +import dataclasses +import unittest + +from framework.decorators import MARKER_KINDS, SpecMarker, spec_marker +from framework.requirements import Catalog, CatalogError, load_catalog + +# strict: problems stop the run; warn: report only; off: no check. +MODES = ("strict", "warn", "off") +CHECKED_PACKAGE = "shopping" +# What a marker may cite: a rule of the catalog's specification, or a rule +# that only older releases state. +CITABLE = ("rule", "removed") +STATUS_PROBLEMS = { + "unknown": "is not in the catalog", + "retired": "is retired: its rule was removed or rewritten", + "not a rule": "is a sentence the review found states no requirement", +} + + +@dataclasses.dataclass(frozen=True) +class LoadedTest: + """What the check needs to know about one loaded test. + + Attributes: + test_id: The test's ID, as the runner reports it. + module: The module the test is defined in. + marker: The test's marker, if it has one. + capabilities: The capabilities the test requires. + + """ + + test_id: str + module: str + marker: SpecMarker | None + capabilities: frozenset[str] + + +@dataclasses.dataclass +class CheckResult: + """What the check found. + + Attributes: + checked: How many tests were checked. + kinds: How many tests carry each kind of marker; "unmarked" counts the + tests with none. + rules: The rules cited, by ID. + problems: Findings that stop the run in strict mode. + warnings: Findings that never stop it. + + """ + + checked: int = 0 + kinds: collections.Counter[str] = dataclasses.field( + default_factory=collections.Counter + ) + rules: set[str] = dataclasses.field(default_factory=set) + problems: list[str] = dataclasses.field(default_factory=list) + warnings: list[str] = dataclasses.field(default_factory=list) + + def report(self) -> str: + """Return the findings as text for the console.""" + counts = ", ".join( + f"{self.kinds[kind]} {kind}" for kind in (*MARKER_KINDS[1:], "unmarked") + ) + lines = [ + f"Requirements check: {self.checked} tests; " + f"{self.kinds['spec_assert']} cite rules ({len(self.rules)} distinct " + f"rules), {counts}" + ] + for title, findings in ( + ("problems", self.problems), + ("warnings", self.warnings), + ): + if findings: + lines.append(f" {title} ({len(findings)}):") + lines.extend(f" - {finding}" for finding in findings) + return "\n".join(lines) + "\n" + + +def in_scope(module: str) -> bool: + """Return whether tests in a module are checked.""" + return module == CHECKED_PACKAGE or module.startswith(f"{CHECKED_PACKAGE}.") + + +def required_capabilities(test_class: object, method: object) -> frozenset[str]: + """Return the capability names a test requires. + + As when the test runs, these are the names given to `requires_capability` + on the test's class, or a class it inherits from, and on the test method. + + Args: + test_class: The test's class. + method: The test method. + + Returns: + The capability names. + + """ + return frozenset( + name + for target in (test_class, method) + for name, _ in getattr(target, "_required_capabilities", ()) + ) + + +def from_unittest(test: unittest.TestCase) -> LoadedTest: + """Describe a test case as unittest loads it.""" + method = getattr(test, test._testMethodName, None) + return LoadedTest( + test_id=test.id(), + module=type(test).__module__, + marker=spec_marker(test), + capabilities=required_capabilities(type(test), method), + ) + + +def from_pytest_item(item: object) -> LoadedTest: + """Describe a test as pytest collects it.""" + method = getattr(item, "obj", None) + return LoadedTest( + test_id=getattr(item, "nodeid", repr(item)), + module=getattr(getattr(item, "module", None), "__name__", ""), + marker=spec_marker(method) if method is not None else None, + capabilities=required_capabilities(getattr(item, "cls", None), method), + ) + + +def check(tests: Iterable[LoadedTest], catalog: Catalog) -> CheckResult: + """Check the marker of every shopping test against the catalog. + + Args: + tests: The loaded tests; those outside the shopping suite are ignored. + catalog: The requirements catalog. + + Returns: + The counts, problems and warnings. + + """ + result = CheckResult() + for test in tests: + if not in_scope(test.module): + continue + result.checked += 1 + if test.marker is None: + result.kinds["unmarked"] += 1 + result.problems.append( + f"{test.test_id}: no marker ({', '.join(MARKER_KINDS)})" + ) + continue + result.kinds[test.marker.kind] += 1 + covered = catalog.with_parents(test.capabilities) + for rule_id in test.marker.rule_ids: + status = catalog.status(rule_id) + if status not in CITABLE: + result.problems.append( + f"{test.test_id}: {rule_id} {STATUS_PROBLEMS[status]}" + ) + continue + result.rules.add(rule_id) + rule = catalog.rule(rule_id) + if status == "removed": + result.warnings.append( + f"{test.test_id}: {rule_id} was removed in {rule.until}; only " + f"{', '.join(rule.versions)} state it" + ) + if not rule.testable: + result.warnings.append( + f"{test.test_id}: {rule_id} is not testable by this suite " + f"({rule.testable_reason})" + ) + if test.capabilities and not covered.intersection(rule.capabilities): + result.warnings.append( + f"{test.test_id}: {rule_id} belongs to " + f"{', '.join(rule.capabilities)}, which the test does not require" + ) + return result + + +def evaluate( + tests: list[LoadedTest], mode: str, catalog_dir: str | None = None +) -> tuple[str, bool]: + """Run the check in a mode. + + Args: + tests: The loaded tests. + mode: One of `MODES`. + catalog_dir: The catalog directory; by default this repository's. + + Returns: + The report to show, empty when nothing was checked, and whether the run + must stop. + + """ + if mode == "off" or not any(in_scope(test.module) for test in tests): + return "", False + try: + catalog = load_catalog(catalog_dir) + except CatalogError as error: + return f"Requirements check: {error}\n", mode == "strict" + result = check(tests, catalog) + return result.report(), mode == "strict" and bool(result.problems) diff --git a/framework/requirements.py b/framework/requirements.py new file mode 100644 index 0000000..ce48cc0 --- /dev/null +++ b/framework/requirements.py @@ -0,0 +1,366 @@ +# Copyright 2026 UCP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Look up specification rules in the shopping requirements catalog. + +`requirements/tools/build_catalog.py` writes the catalog to +`requirements/catalog/`: one file of rules per specification page, under +`shopping/`; `requirements.lock.json`, which records every rule ID ever +issued; and `history.json`, which records the releases that state each rule +and the rules that only older releases state. Tests cite rules by ID with +`framework.decorators.spec_assert`; this module says what an ID names. +""" + +from collections.abc import Iterable, Mapping +import dataclasses +import functools +import json +from pathlib import Path +import re +from types import MappingProxyType +from typing import Any + +_REPO_CATALOG_DIR = ( + Path(__file__).resolve().parents[1] / "requirements" / "catalog" +) +_WHEEL_CATALOG_DIR = Path(__file__).resolve().parent / "_catalog" + + +def _default_catalog_dir( + repo_dir: Path = _REPO_CATALOG_DIR, wheel_dir: Path = _WHEEL_CATALOG_DIR +) -> Path: + """Return the repository catalog directory, or the wheel's bundled copy.""" + return repo_dir if repo_dir.is_dir() else wheel_dir + + +DEFAULT_CATALOG_DIR = _default_catalog_dir() +PAGES_DIR = "shopping" +LOCK_FILE = "requirements.lock.json" +INDEX_FILE = "capabilities.json" +HISTORY_FILE = "history.json" +# The catalog schema's pattern for a rule ID. +ID_RE = re.compile(r"^REQ-[A-Z0-9-]+-[0-9]{2,}$") +# The version of the specification the catalog was built from: newer than +# every release. +DRAFT = "draft" + + +class CatalogError(Exception): + """The catalog is missing, malformed, or out of step with its lock.""" + + +@dataclasses.dataclass(frozen=True) +class Statement: + """How one release of the specification states a rule. + + Attributes: + version: The release, such as "2026-04-08". + level: The rule's RFC 2119 level in that release. + clause: The rule's wording in that release. + source_file: The page that states it, as the release names the page. + line: The line of that page it starts on. + + """ + + version: str + level: str + clause: str + source_file: str + line: int + + +@dataclasses.dataclass(frozen=True) +class Rule: + """One rule in the catalog. + + Attributes: + id: The rule's stable ID. + level: Its RFC 2119 level, as corrected by the review if it was. + clause: Its wording, as the specification states it. + capabilities: The capabilities it belongs to. + source_file: The specification page it is on. + line: The line of that page it starts on. + link: Where it is published: its page and anchor, relative to the root + of a release of the specification site. + testable: Whether this suite can test it. + testable_reason: Why it is or is not testable. + is_rule: False when the review found it states no requirement. + since: The first version that states it: a release, or `DRAFT`. + until: For a removed rule, the first version after the last one that + states it; None while the catalog's version states it. + statements: How each release that states it states it, oldest first. + The catalog's own version isn't among them. + + """ + + id: str + level: str + clause: str + capabilities: tuple[str, ...] + source_file: str + line: int + link: str + testable: bool + testable_reason: str + is_rule: bool + since: str = DRAFT + until: str | None = None + statements: tuple[Statement, ...] = () + + @property + def versions(self) -> tuple[str, ...]: + """Return every version that states the rule, oldest first.""" + stated = tuple(statement.version for statement in self.statements) + return stated if self.until else (*stated, DRAFT) + + def level_in(self, version: str) -> str | None: + """Return the rule's level in a version, or None if it isn't stated. + + Args: + version: A release, or `DRAFT` for the catalog's own version. + + Returns: + The level that version states, or None. + + """ + if version == DRAFT: + return self.level if self.until is None else None + for statement in self.statements: + if statement.version == version: + return statement.level + return None + + +@dataclasses.dataclass(frozen=True) +class Capability: + """One capability in the catalog's index. + + Attributes: + name: Its name, such as `dev.ucp.shopping.checkout`. + kind: "extension" for an extension, otherwise "capability". + extends: For an extension, the capabilities it extends. + + """ + + name: str + kind: str = "capability" + extends: tuple[str, ...] = () + + +@dataclasses.dataclass(frozen=True) +class Catalog: + """The catalog's rules by stable ID, and the IDs retired from it. + + Attributes: + rules: Every rule in the catalog, by ID. + retired: IDs issued for rules the specification no longer states. + extends: For each extension, the capabilities it extends. + capabilities: The capabilities in the catalog's index, in its order. + spec_commit: The specification commit the catalog was built from. + removed: The retired IDs of rules that only older releases state, with + the rule each names, by ID. + versions: Every version the history covers, oldest first: the + releases, then `DRAFT`. + + """ + + rules: Mapping[str, Rule] + retired: frozenset[str] + extends: Mapping[str, tuple[str, ...]] = dataclasses.field( + default_factory=lambda: MappingProxyType({}) + ) + capabilities: tuple[Capability, ...] = () + spec_commit: str = "" + removed: Mapping[str, Rule] = dataclasses.field( + default_factory=lambda: MappingProxyType({}) + ) + versions: tuple[str, ...] = (DRAFT,) + + def status(self, rule_id: str) -> str: + """Return what an ID names. + + One of: "rule", "not a rule", "removed", "retired" or "unknown". A test + should cite only IDs whose status is "rule" or "removed". "not a rule" is + a sentence the review found states no requirement. "removed" is a rule + that only older releases state. Any other retired ID's rule was removed + or rewritten, so a test citing it needs a new ID. + + Args: + rule_id: The ID to look up. + + Returns: + The ID's status. + + """ + rule = self.rules.get(rule_id) + if rule is not None: + return "rule" if rule.is_rule else "not a rule" + removed = self.removed.get(rule_id) + if removed is not None: + return "removed" if removed.is_rule else "not a rule" + return "retired" if rule_id in self.retired else "unknown" + + def rule(self, rule_id: str) -> Rule | None: + """Return the rule an ID names, removed ones included, or None.""" + return self.rules.get(rule_id) or self.removed.get(rule_id) + + def with_parents(self, capabilities: Iterable[str]) -> frozenset[str]: + """Return capabilities together with every capability they extend. + + A server that offers an extension also offers what it extends, so a + test that requires the discount extension exercises checkout too. + + Args: + capabilities: Capability names. + + Returns: + The names, with the capabilities they extend, directly or not. + + """ + found = set(capabilities) + pending = list(found) + while pending: + for parent in self.extends.get(pending.pop(), ()): + if parent not in found: + found.add(parent) + pending.append(parent) + return frozenset(found) + + +def load_catalog(catalog_dir: str | Path | None = None) -> Catalog: + """Load the catalog, reading it from disk only once per directory. + + Args: + catalog_dir: The catalog directory. By default, this repository's + `requirements/catalog/`. + + Returns: + The catalog. + + Raises: + CatalogError: If the catalog is missing or malformed, its rules are not + exactly its lock's active IDs, or a removed rule's ID isn't retired. + + """ + return _load(Path(catalog_dir or DEFAULT_CATALOG_DIR).resolve()) + + +@functools.cache +def _load(catalog_dir: Path) -> Catalog: + """Read and check the catalog in a directory.""" + pages = sorted((catalog_dir / PAGES_DIR).rglob("*.json")) + lock_path = catalog_dir / LOCK_FILE + if not pages or not lock_path.is_file(): + raise CatalogError( + f"no catalog in {catalog_dir}; generate it with " + "requirements/tools/build_catalog.py" + ) + rules: dict[str, Rule] = {} + for page in pages: + for record in _read(page).get("requirements", []): + rule = _checked_rule(page, record) + if rule.id in rules: + raise CatalogError(f"{page}: {rule.id} is malformed or repeated") + rules[rule.id] = rule + entries = _read(lock_path).get("entries", []) + active = {entry["id"] for entry in entries if entry["status"] == "active"} + if active != set(rules): + raise CatalogError( + f"the catalog in {catalog_dir} and its lock disagree (only in the " + f"catalog: {sorted(set(rules) - active)[:5]}; only in the lock: " + f"{sorted(active - set(rules))[:5]}); regenerate the catalog" + ) + retired = frozenset( + entry["id"] for entry in entries if entry["status"] == "retired" + ) + history_path = catalog_dir / HISTORY_FILE + history = _read(history_path) if history_path.is_file() else {} + removed: dict[str, Rule] = {} + for record in history.get("removed", []): + rule = _checked_rule(history_path, record) + if rule.id not in retired or rule.id in removed: + raise CatalogError( + f"{history_path}: removed rule {rule.id} is repeated or not retired " + "in the lock; regenerate the catalog" + ) + removed[rule.id] = rule + index_path = catalog_dir / INDEX_FILE + index = _read(index_path) if index_path.is_file() else {} + capabilities = tuple( + Capability( + name=entry["name"], + kind=entry.get("kind", "capability"), + extends=tuple(entry.get("extends", ())), + ) + for entry in index.get("capabilities", []) + ) + return Catalog( + rules=MappingProxyType(dict(sorted(rules.items()))), + retired=retired, + extends=MappingProxyType({c.name: c.extends for c in capabilities}), + capabilities=capabilities, + spec_commit=index.get("suite", {}).get("spec_commit", ""), + removed=MappingProxyType(dict(sorted(removed.items()))), + versions=tuple(history.get("versions", (DRAFT,))), + ) + + +def _read(path: Path) -> dict[str, Any]: + """Read a JSON file of the catalog.""" + try: + return json.loads(path.read_text(encoding="utf-8")) + except (OSError, json.JSONDecodeError) as error: + raise CatalogError(f"cannot read {path}: {error}") from error + + +def _checked_rule(path: Path, record: dict[str, Any]) -> Rule: + """Build a rule from a record of a catalog file, or raise CatalogError.""" + try: + rule = _rule(record) + except (KeyError, TypeError) as error: + raise CatalogError(f"{path}: malformed record ({error})") from error + if not ID_RE.match(rule.id): + raise CatalogError(f"{path}: {rule.id} is malformed or repeated") + return rule + + +def _rule(record: dict[str, Any]) -> Rule: + """Build a rule from a catalog record and the suite's additions to it.""" + suite = record.get("suite", {}) + source = record["source"] + anchor = source.get("anchor") + return Rule( + id=record["id"], + level=suite.get("review", {}).get("level") or record["level"], + clause=record["clause"], + capabilities=tuple(record["capabilities"]), + source_file=source["file"], + line=source["start_line"], + link=f"{source['page']}#{anchor}" if anchor else source["page"], + testable=bool(suite.get("testable")), + testable_reason=suite.get("testable_reason", ""), + is_rule=not suite.get("excluded", False), + since=suite.get("since", DRAFT), + until=suite.get("until"), + statements=tuple( + Statement( + version=entry["version"], + level=entry["level"], + clause=entry.get("clause", record["clause"]), + source_file=entry["file"], + line=entry["start_line"], + ) + for entry in suite.get("releases", ()) + ), + ) diff --git a/pyproject.toml b/pyproject.toml index 0d260b1..a512863 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -46,6 +46,11 @@ only-include = [ "shopping-agent-test.json", ] +[tool.hatch.build.targets.wheel.force-include] +# Package the catalog inside `framework/` so wheel installs find it without +# putting a top-level `requirements/` directory into `site-packages`. +"requirements/catalog" = "framework/_catalog" + [tool.uv.sources] # The relative path is stored here ucp-sdk = { path = "../python-sdk/", editable = true } diff --git a/requirements/README.md b/requirements/README.md new file mode 100644 index 0000000..8366232 --- /dev/null +++ b/requirements/README.md @@ -0,0 +1,242 @@ +# Shopping requirements catalog + +A catalog of every RFC 2119 rule on the shopping pages of the specification, +with a stable ID for each, so that the shopping tests can say which rule they +check. It is generated from a pinned commit of the specification with the +requirements extractor from the `.github` repository, plus two options the +extractor doesn't have yet (see [How it was built](#how-it-was-built)). + +> The IDs are stable within this repository (see [Stable IDs](#stable-ids)). +> They are not official IDs: those will be issued in the `ucp` repository, +> and every lock entry records its `text_digest` so these IDs can be mapped to +> them. + +## Contents + +| Path | What | +| -------------------------------- | ------------------------------------------------------------------------------------- | +| `catalog/shopping/**/*.json` | One file per specification page, with every rule on that page | +| `catalog/capabilities.json` | Each capability: extension or not, what it extends, its schema, pages and rule counts | +| `catalog/requirements.lock.json` | Every rule ID ever issued, with the wording it was issued for | +| `catalog/history.json` | The releases read, the rules only older releases state, and rules that left the pages | +| `catalog/extraction_report.json` | The extractor's diagnostics for the run | +| `releases.json` | The releases the history is read from, at pinned commits, and where their pages were | +| `review.json` | A person's decisions on 204 rules the automatic pass couldn't settle | +| `tools/build_catalog.py` | Regenerates the `catalog/` folder from the inputs below | + +## How it was built + +- **Specification:** `Universal-Commerce-Protocol/ucp` at `f2626c28`, every + page under `docs/specification/shopping/`, including `extensions/`. +- **Extractor:** `org-tools/requirements-extractor` from + `Universal-Commerce-Protocol/.github` (#76, `16f3afa`, version 0.4.0). +- **Two preview options:** + - every page gets a capability from its `Capability Name` bullet, or else + from its file path (`extensions/.md` belongs to + `dev.ucp.shopping.`; a shared catalog page belongs to both catalog + capabilities); + - upper-case RFC 2119 keywords count even when they aren't bold. +- **Extensions:** an extension's parents come from its schema's `$defs` keys + that name another capability. +- **Testable:** this suite plays the platform and calls a business over REST, + so a rule is testable when it sits on a transport-neutral or REST page and + is aimed at the business, as corrected by `review.json`. +- **Review:** decisions are keyed by page and `text_digest`, not by ID, so a + reworded rule needs a fresh decision: a decision whose wording no longer + matches a rule fails the build. + +Each record keeps the extractor's fields, with `id` holding the stable ID; +everything this repository adds is in its `suite` object, including the +extractor's positional ID as `suite.positional_id`. + +## Stable IDs + +Each rule's ID, such as `REQ-SHOPPING-CART-0007`, comes from +`catalog/requirements.lock.json`, so it doesn't change when the page around it +does. The prefix comes from the page's capability (`SHOPPING-CATALOG` for the +shared catalog pages), followed by a four-digit number. A lock entry records +the rule's page, its wording and digest, any earlier digests, whether it is +active or retired, and the specification commits it was issued and retired +at. + +Each run matches the rules it finds against the lock, page by page: + +1. **Same wording:** a rule with the same page and `text_digest` as an entry + keeps that entry's ID. Copies of one sentence on a page take that + wording's IDs oldest first, in page order. A retired ID whose wording comes + back is restored. +2. **Reworded:** a rule left over takes the ID of a still-unmatched active + entry on the same page whose wording is at least 85% alike, most alike + first. The entry keeps its old digests in `previous_digests`, and the run + lists the rule as carried over so a person can confirm it's the same rule. +3. **New:** a rule still left over gets the next number for its prefix. +4. **Retired:** an active entry that matched nothing is marked `retired`. Its + number is never issued again. A rule only older releases state also has a + retired ID (see [Release history](#release-history)). + +A rule that moves to another page is retired on the old page and gets a new +ID on the new one. If one of two identical sentences on a page is removed, the +copy that stays keeps the older ID, whichever copy was removed. + +## Release history + +The catalog also records which releases state each rule, so that a server +can be measured against the release it implements. `releases.json` lists the +releases, each at a pinned commit of its release branch: 2026-01-11, +2026-01-23, 2026-04-08 and 2026-08-25. The build reads each one's shopping +pages from a clone of the specification repository. The releases before +2026-08-25 have no shopping folder, so `releases.json` gives each of their +shopping pages its path today; its rules then get the capability and +testability that today's page gives them. + +Releases are matched newest first, each against the wording that each rule +has in the next newer version, starting with the pinned specification: + +1. the same wording on the same page, then on another page of the same + capability; +2. the same wording under another list stem, or none, for a wording of at + least five words (2026-01-11 has no stem for some lists); +3. a wording at least 85% alike, on the same page, then on another page of the + same capability. + +A release's rule that matches nothing is one of two things: + +- **Moved out of the shopping pages:** the pinned specification states it on + another page, such as `embedded-protocol.md`. It isn't in the catalog. +- **Removed:** only older releases state it. It gets a stable ID of its own, + retired in the lock from the start, and `catalog/history.json` keeps its + record: wording, level, capability and page. + +Each rule's `suite.since` is the first version that states it, and +`suite.releases` says how each release states it: the page and line as the +release names them, the level, the digest, and the wording when it differs. +A removed rule also has `suite.until`, the first version that doesn't state +it. The build lists every match on a reworded wording for a person to check. +If the review finds that the meaning changed, a split in `review.json` makes +the older wording a removed rule of its own: + +```json +{ + "splits": [{ "id": "REQ-SHOPPING-…", "before": "2026-08-25", "reason": "…" }] +} +``` + +One limit: the pinned specification renders the shared REST header rules +(`UCP-Agent` and `Idempotency-Key`) with the `header_requirements` macro, +which the extractor reads as plain text. The catalog has no rule for them on +the checkout, cart, catalog and order REST pages, and the history counts the +older releases' copies as moved out, because the lodging pages still state +them in full. + +## Linking tests to rules + +Each shopping test says which rules it checks, with one marker from +`framework/decorators.py`: + +- `@spec_assert("REQ-SHOPPING-CHECKOUT-0133", ...)`: the rules its assertions + check, by stable ID, each with a comment giving the rule's wording. A rule + they check only in part is wrapped in `partly(id, gap)`, where the gap says + what the test leaves unchecked; +- `@no_rule("...")`: the spec describes the behavior without an RFC 2119 + keyword, so there is no rule to cite; +- `@scenario("...")`: the test checks a store's own data, such as a + free-shipping threshold, rather than a rule; +- `@outside_catalog("...")`: the test checks a rule on a specification page + this catalog doesn't cover, such as the core overview page; +- `@older_version("2026-04-08", "...")`: the test checks behavior from an + older release that this specification has changed, so it needs updating. + +For example, a totals test that checks one rule fully and another in part: + +```python +@spec_assert( + partly( + "REQ-SHOPPING-CHECKOUT-0016", # line total MUST be price x quantity + "a quantity of 1 only, so scale and rounding aren't checked", + ), + "REQ-SHOPPING-CHECKOUT-0134", # Exactly one "total" MUST be present +) +``` + +`framework/requirements.py` looks rules up in the catalog. Before any test +runs, the runner checks every shopping test's marker against it, and so does +pytest: + +- **Problems** stop the run: a test with no marker, or an ID that isn't in the + catalog, was retired, or the review found isn't a rule. +- **Warnings** don't: a rule this suite can't test, or one outside the + capabilities the test requires. + +`--dry-run` runs the check without a server. `--requirements_check=warn` +(or `--requirements-check=warn`, also accepted by pytest) reports problems +without stopping, and `off` skips the check. Unit tests for the markers, the +loader and the check are in `tests/`: run `python -m pytest tests`. + +## Numbers at `f2626c28` + +- 510 rules extracted: 395 bold and 115 found through capitals. The review + found 3 aren't rules, leaving 507. +- 211 are testable by this suite, 98 of them MUST or MUST NOT. + +| Capability | Rules | Testable | Testable MUST | +| --------------------------------- | ----: | -------: | ------------: | +| `dev.ucp.shopping.checkout` | 250 | 76 | 35 | +| `dev.ucp.shopping.cart` | 65 | 21 | 8 | +| `dev.ucp.shopping.catalog.lookup` | 61 | 38 | 16 | +| `dev.ucp.shopping.catalog.search` | 55 | 30 | 11 | +| `dev.ucp.shopping.fulfillment` | 55 | 34 | 13 | +| `dev.ucp.shopping.order` | 40 | 24 | 17 | +| `dev.ucp.shopping.buyer_consent` | 17 | 4 | 3 | +| `dev.ucp.shopping.discount` | 9 | 7 | 4 | + +The 46 rules on the shared catalog pages count under both catalog +capabilities. + +This catalog covers rules in the specification pages. Schema field +descriptions hold 86 more upper-case keyword sentences, which aren't +included. + +### By release + +| Version | Shopping rules | Testable MUST stated | Pinned testable MUST first stated | +| ------------ | -------------: | -------------------: | --------------------------------: | +| `2026-01-11` | 140 | 18 | 12 | +| `2026-01-23` | 150 | 19 | 1 | +| `2026-04-08` | 379 | 60 | 44 | +| `2026-08-25` | 512 | 96 | 39 | +| draft | 507 | 98 | 2 | + +- **Removed rules:** 22, of which 8 are testable MUST rules that the review + hasn't looked at yet. Among them are the webhook rules of the first two + releases: payloads signed as a detached JWT in a `Request-Signature` + header, which 2026-04-08 replaced with RFC 9421 signatures. +- **Moved out:** 72 statements in older releases: 53 now on + `embedded-protocol.md`, and 19 header rules the shopping pages now render + with a macro (see [Release history](#release-history)). + +## Regenerate + +From the repository root, with a `ucp` checkout at `f2626c28`, a `ucp` clone +that has the commits in `releases.json` (the `release/*` branches of the +`Universal-Commerce-Protocol/ucp` repository), and a `.github` checkout on +`main` (`16f3afa` or later): + +```bash +uv run --no-project requirements/tools/build_catalog.py \ + --spec-root= \ + --spec-commit=f2626c28b8288976eee5bda77f3a9b1ddc0132b1 \ + --releases-repo= \ + --extractor-dir=<.github checkout>/org-tools/requirements-extractor/scripts +``` + +The output is deterministic: a second run writes identical bytes. Add +`--check` to write nothing and fail if any output, the lock included, would +change. + +Keep `catalog/requirements.lock.json` committed with the catalog. It is the +only record of the IDs issued so far: without it, the next run would issue +every ID again, from scratch. + +The `catalog/` folder is excluded from prettier and codespell in +`.pre-commit-config.yaml`, and from cspell in `.cspell.json`, so that it stays +exactly as the tool writes it. diff --git a/requirements/catalog/capabilities.json b/requirements/catalog/capabilities.json new file mode 100644 index 0000000..89a87c4 --- /dev/null +++ b/requirements/catalog/capabilities.json @@ -0,0 +1,241 @@ +{ + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "extends_from": "each extension schema's $defs keys that name another capability", + "capabilities": [ + { + "name": "dev.ucp.shopping.buyer_consent", + "kind": "extension", + "extends": [ + "dev.ucp.shopping.cart", + "dev.ucp.shopping.checkout" + ], + "extended_by": [], + "schema": "source/schemas/shopping/buyer_consent.json", + "rules": 17, + "testable_rules": 4, + "testable_must": 3, + "pages": [ + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "rules": 17 + } + ] + }, + { + "name": "dev.ucp.shopping.cart", + "kind": "capability", + "extends": [], + "extended_by": [ + "dev.ucp.shopping.buyer_consent", + "dev.ucp.shopping.discount" + ], + "schema": "source/schemas/shopping/cart.json", + "rules": 65, + "testable_rules": 21, + "testable_must": 8, + "pages": [ + { + "file": "docs/specification/shopping/cart/embedded.md", + "rules": 28 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "rules": 29 + }, + { + "file": "docs/specification/shopping/cart/mcp.md", + "rules": 4 + }, + { + "file": "docs/specification/shopping/cart/rest.md", + "rules": 4 + } + ] + }, + { + "name": "dev.ucp.shopping.catalog.lookup", + "kind": "capability", + "extends": [], + "extended_by": [ + "dev.ucp.shopping.fulfillment" + ], + "schema": "source/schemas/shopping/catalog_lookup.json", + "rules": 61, + "testable_rules": 38, + "testable_must": 16, + "pages": [ + { + "file": "docs/specification/shopping/catalog/index.md", + "rules": 35, + "shared_with": [ + "dev.ucp.shopping.catalog.search" + ] + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "rules": 16 + }, + { + "file": "docs/specification/shopping/catalog/mcp.md", + "rules": 6, + "shared_with": [ + "dev.ucp.shopping.catalog.search" + ] + }, + { + "file": "docs/specification/shopping/catalog/rest.md", + "rules": 4, + "shared_with": [ + "dev.ucp.shopping.catalog.search" + ] + } + ] + }, + { + "name": "dev.ucp.shopping.catalog.search", + "kind": "capability", + "extends": [], + "extended_by": [ + "dev.ucp.shopping.fulfillment" + ], + "schema": "source/schemas/shopping/catalog_search.json", + "rules": 55, + "testable_rules": 30, + "testable_must": 11, + "pages": [ + { + "file": "docs/specification/shopping/catalog/index.md", + "rules": 35, + "shared_with": [ + "dev.ucp.shopping.catalog.lookup" + ] + }, + { + "file": "docs/specification/shopping/catalog/mcp.md", + "rules": 6, + "shared_with": [ + "dev.ucp.shopping.catalog.lookup" + ] + }, + { + "file": "docs/specification/shopping/catalog/rest.md", + "rules": 4, + "shared_with": [ + "dev.ucp.shopping.catalog.lookup" + ] + }, + { + "file": "docs/specification/shopping/catalog/search.md", + "rules": 10 + } + ] + }, + { + "name": "dev.ucp.shopping.checkout", + "kind": "capability", + "extends": [], + "extended_by": [ + "dev.ucp.shopping.buyer_consent", + "dev.ucp.shopping.discount", + "dev.ucp.shopping.fulfillment" + ], + "schema": "source/schemas/shopping/checkout.json", + "rules": 250, + "testable_rules": 76, + "testable_must": 35, + "pages": [ + { + "file": "docs/specification/shopping/checkout/a2a.md", + "rules": 1 + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "rules": 77 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "rules": 148 + }, + { + "file": "docs/specification/shopping/checkout/mcp.md", + "rules": 12 + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "rules": 12 + } + ] + }, + { + "name": "dev.ucp.shopping.discount", + "kind": "extension", + "extends": [ + "dev.ucp.shopping.cart", + "dev.ucp.shopping.checkout" + ], + "extended_by": [], + "schema": "source/schemas/shopping/discount.json", + "rules": 9, + "testable_rules": 7, + "testable_must": 4, + "pages": [ + { + "file": "docs/specification/shopping/extensions/discount.md", + "rules": 9 + } + ] + }, + { + "name": "dev.ucp.shopping.fulfillment", + "kind": "extension", + "extends": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search", + "dev.ucp.shopping.checkout" + ], + "extended_by": [], + "schema": "source/schemas/shopping/fulfillment.json", + "rules": 55, + "testable_rules": 34, + "testable_must": 13, + "pages": [ + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "rules": 55 + } + ] + }, + { + "name": "dev.ucp.shopping.order", + "kind": "capability", + "extends": [], + "extended_by": [], + "schema": "source/schemas/shopping/order.json", + "rules": 40, + "testable_rules": 24, + "testable_must": 17, + "pages": [ + { + "file": "docs/specification/shopping/order/index.md", + "rules": 26 + }, + { + "file": "docs/specification/shopping/order/mcp.md", + "rules": 7 + }, + { + "file": "docs/specification/shopping/order/rest.md", + "rules": 7 + } + ] + } + ] +} diff --git a/requirements/catalog/extraction_report.json b/requirements/catalog/extraction_report.json new file mode 100644 index 0000000..b59b355 --- /dev/null +++ b/requirements/catalog/extraction_report.json @@ -0,0 +1,2506 @@ +{ + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_spec": [ + "docs/specification/shopping" + ], + "summary": { + "total": 510, + "must_count": 213, + "must_not_count": 53, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 111, + "should_not_count": 4, + "may_count": 129, + "by_level": { + "MAY": 129, + "MUST": 213, + "MUST NOT": 53, + "SHOULD": 111, + "SHOULD NOT": 4 + }, + "by_actor": { + "AGENT": 1, + "BUSINESS": 154, + "BUYER": 3, + "EMBEDDED_CHECKOUT": 22, + "EXTENSION": 15, + "HOST": 42, + "IMPLEMENTATION": 17, + "PLATFORM": 118, + "UNRESOLVED": 138 + }, + "by_file": { + "docs/specification/shopping/cart/embedded.md": 28, + "docs/specification/shopping/cart/index.md": 29, + "docs/specification/shopping/cart/mcp.md": 4, + "docs/specification/shopping/cart/rest.md": 4, + "docs/specification/shopping/catalog/index.md": 35, + "docs/specification/shopping/catalog/lookup.md": 16, + "docs/specification/shopping/catalog/mcp.md": 6, + "docs/specification/shopping/catalog/rest.md": 5, + "docs/specification/shopping/catalog/search.md": 10, + "docs/specification/shopping/checkout/a2a.md": 1, + "docs/specification/shopping/checkout/embedded.md": 77, + "docs/specification/shopping/checkout/index.md": 150, + "docs/specification/shopping/checkout/mcp.md": 12, + "docs/specification/shopping/checkout/rest.md": 12, + "docs/specification/shopping/extensions/buyer-consent.md": 17, + "docs/specification/shopping/extensions/discount.md": 9, + "docs/specification/shopping/extensions/fulfillment.md": 55, + "docs/specification/shopping/order/index.md": 26, + "docs/specification/shopping/order/mcp.md": 7, + "docs/specification/shopping/order/rest.md": 7 + }, + "with_condition": 131, + "with_referenced_fields": 244, + "from_compound_split": 63, + "diagnostics": { + "actor_after_keyword_only": 21, + "actor_low_confidence": 52, + "actor_unresolved": 138, + "annotation_as_obligation": 5, + "annotations_excluded": 32, + "candidates_without_emphasis": 0, + "compounds_not_split": 2, + "duplicate_requirements": 23, + "empty_after_split": 0, + "multi_obligation_sentences": 31, + "rfc2119_boilerplate": 0 + } + }, + "diagnostics": { + "actor_after_keyword_only": [ + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 140, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "text": "Parameters **SHOULD** use either `ep` or `ep_cart` prefixes to avoid namespace pollution and clearly distinguish ECaP parameters from business-specific query parameters:", + "candidate": "business" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 162, + "section": "Cart Capability - EP Binding > Transport & Messaging", + "text": "The `ucp.version` in all responses **MUST** echo the `ep_version` negotiated during session initialization and confirmed by the host in the `ep.cart.ready` response.", + "candidate": "host" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 185, + "section": "Cart Capability - EP Binding > Message API Reference > Message Categories > Core Messages", + "text": "Core messages are defined by the ECaP specification and **MUST** be supported by all implementations.", + "candidate": "implementation" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 209, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "**MUST** be a subset of both `ep_cart_delegate` (what host requested) and `config.delegate` from the cart response (what business allows).", + "candidate": "business" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 270, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "Currently, this object only supports a `port` field, which **MUST** be transferred to the embedded cart context (e.g., with `{transfer: [port2]}` on the host's `iframe.contentWindow.postMessage()` call)", + "candidate": "host" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 267, + "section": "Cart Capability > Entities > Signals", + "text": "Signal values MUST NOT be buyer-asserted claims.", + "candidate": "buyer" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 203, + "section": "Catalog Capability > Shared Entities > Signals", + "text": "Signal values MUST NOT be buyer-asserted claims.", + "candidate": "buyer" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 300, + "section": "Catalog Capability > Shared Entities > Media > External Video", + "text": "Before embedding, it **MUST** decline the item unless `url` is an absolute `https` URL without userinfo that is not same-site with the Platform.", + "candidate": "platform" + }, + { + "file": "docs/specification/shopping/catalog/search.md", + "line": 40, + "section": "Catalog Search Capability > Search Inputs", + "text": "A valid search request MUST include at least one of: a `query` string, one or more `filters`, or an extension-defined input.", + "candidate": "extension" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 400, + "section": "Checkout Capability - EP Binding > Requirements > Navigation Constraints", + "text": "These exceptions **SHOULD** return the user to the checkout flow upon completion.", + "candidate": "buyer" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 409, + "section": "Checkout Capability - EP Binding > Transport & Messaging", + "text": "The `ucp.version` in all responses **MUST** echo the `ec_version` negotiated during session initialization and confirmed by the host in the `ec.ready` response.", + "candidate": "host" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 432, + "section": "Checkout Capability - EP Binding > Message API Reference > Message Categories > Core Messages", + "text": "Core messages are defined by the ECP specification and **MUST** be supported by all implementations.", + "candidate": "implementation" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 475, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "**MUST** be a subset of both `ec_delegate` (what host requested) and `config.delegate` from the checkout response (what business allows).", + "candidate": "business" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 561, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "Currently, this object only supports a `port` field, which **MUST** be transferred to the embedded checkout context (e.g., with `{transfer: [port2]}` on the host's `iframe.contentWindow.postMessage()` call)", + "candidate": "embedded_checkout" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 242, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "text": "**Ordering increment.** The sale basis **MAY** declare an [`increment`](../../overview/index.md#ordering-increment) — the ordering granularity, in steps, the Business sells in.", + "candidate": "business" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 242, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "text": "such revisions **SHOULD** stay on the increment grid so subsequent Platform stepper edits from the revised value remain on-grid.", + "candidate": "platform" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 374, + "section": "Order Capability > Example: count-sold, measure-priced settlement", + "text": "its unit identity **MUST** match the pricing basis (no conversion), and a pure price settlement uses `quantity: 0` so the count is untouched. (A settled `measure` is Business-recorded fact", + "candidate": "business" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 729, + "section": "Order Capability > Events > Webhook Signature Verification", + "text": "Webhook payloads **MUST** be signed by the business and verified by the platform to ensure authenticity and integrity.", + "candidate": "business" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 839, + "section": "Order Capability > Events > Guidelines", + "text": "**MUST** send retries with the original `Webhook-Id` and `Webhook-Timestamp`; a retry redelivers the same event, and platforms deduplicate on `Webhook-Id` and order deliveries by `Webhook-Timestamp`", + "candidate": "platform" + }, + { + "file": "docs/specification/shopping/order/mcp.md", + "line": 293, + "section": "Order Capability - MCP Binding > Conformance", + "text": "**SHOULD** delegate to the business via `permalink_url` for the authoritative order experience - the business site is the source of truth for order details and post-purchase operations", + "candidate": "business" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "line": 251, + "section": "Order Capability - REST Binding > Conformance", + "text": "**SHOULD** delegate to the business via `permalink_url` for the authoritative order experience - the business site is the source of truth for order details and post-purchase operations", + "candidate": "business" + } + ], + "actor_low_confidence": [ + { + "file": "docs/specification/shopping/cart/index.md", + "line": 145, + "section": "Cart Capability > Guidelines > Platform", + "text": "**MAY** use carts for pre-purchase exploration and session persistence.", + "actor": "platform", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 146, + "section": "Cart Capability > Guidelines > Platform", + "text": "**SHOULD** convert cart to checkout when user expresses purchase intent.", + "actor": "platform", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 147, + "section": "Cart Capability > Guidelines > Platform", + "text": "**MAY** display `continue_url` for handoff to business UI.", + "actor": "platform", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 148, + "section": "Cart Capability > Guidelines > Platform", + "text": "**SHOULD** handle `not_found` gracefully when cart expires or is canceled.", + "actor": "platform", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 152, + "section": "Cart Capability > Guidelines > Business", + "text": "**SHOULD** provide `continue_url` for cart handoff and session recovery.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 154, + "section": "Cart Capability > Guidelines > Business", + "text": "**SHOULD** provide estimated totals when calculable.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 155, + "section": "Cart Capability > Guidelines > Business", + "text": "**MAY** omit fulfillment totals until checkout when address is unknown.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 156, + "section": "Cart Capability > Guidelines > Business", + "text": "**SHOULD** return informational messages for validation warnings.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 157, + "section": "Cart Capability > Guidelines > Business", + "text": "**MAY** set cart expiry via `expires_at`.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 158, + "section": "Cart Capability > Guidelines > Business", + "text": "**SHOULD** follow [cart lifecycle requirements](#cart-to-checkout-conversion) when checkout is initialized via `cart_id`.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/catalog/mcp.md", + "line": 740, + "section": "Catalog - MCP Binding > Error Handling > Business Outcomes > Example: All Products Not Found", + "text": "The response MAY include informational messages indicating which identifiers were not found.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/catalog/rest.md", + "line": 633, + "section": "Catalog - REST Binding > Error Handling > Business Outcomes > Example: All Products Not Found", + "text": "The response MAY include informational messages indicating which identifiers were not found.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 195, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "text": "The version is negotiated at session initialization and **MUST** remain constant for the lifetime of the ECP session — neither party may change the version after the handshake.", + "actor": "embedded_checkout", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 202, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "text": "**SHOULD** be a subset of `config.delegate` from the embedded service binding.", + "actor": "embedded_checkout", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 293, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL > Color Scheme", + "text": "When `ec_color_scheme` is explicitly provided, it **MUST** override the system preference, be applied immediately upon load, and be enforced for the duration of the session.", + "actor": "embedded_checkout", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1002, + "section": "Checkout Capability > Guidelines > Platform", + "text": "**MAY** engage an agent to facilitate the checkout session (e.g. add items to the checkout session, select fulfillment address).", + "actor": "platform", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1007, + "section": "Checkout Capability > Guidelines > Platform", + "text": "**MAY** send the user from the trusted, deterministic UI back to the agent at any time.", + "actor": "platform", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1010, + "section": "Checkout Capability > Guidelines > Platform", + "text": "**MAY** provide agent context when the platform indicates that the request was done by an agent.", + "actor": "platform", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1012, + "section": "Checkout Capability > Guidelines > Platform", + "text": "**MUST** use `continue_url` when checkout status is `requires_escalation`.", + "actor": "platform", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1013, + "section": "Checkout Capability > Guidelines > Platform", + "text": "**MAY** use `continue_url` to hand off to business UI in other situations.", + "actor": "platform", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1014, + "section": "Checkout Capability > Guidelines > Platform", + "text": "When performing handoff, **SHOULD** prefer business-provided `continue_url` over platform-constructed checkout permalinks.", + "actor": "platform", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1019, + "section": "Checkout Capability > Guidelines > Business", + "text": "**MUST** send a confirmation email after the checkout has been completed.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1020, + "section": "Checkout Capability > Guidelines > Business", + "text": "**SHOULD** provide accurate error messages.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1021, + "section": "Checkout Capability > Guidelines > Business", + "text": "Logic handling the checkout sessions **MUST** be deterministic.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1022, + "section": "Checkout Capability > Guidelines > Business", + "text": "**MUST** provide `continue_url` when returning `status` = `requires_escalation`.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1024, + "section": "Checkout Capability > Guidelines > Business", + "text": "**MUST** include at least one message with `severity` of `requires_buyer_input` or `requires_buyer_review` when returning `status` = `requires_escalation`.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1027, + "section": "Checkout Capability > Guidelines > Business", + "text": "**SHOULD** provide `continue_url` in all non-terminal checkout responses.", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/mcp.md", + "line": 825, + "section": "Checkout Capability - MCP Binding > Implementation", + "text": "Implementers **MUST** apply this transformation:", + "actor": "implementation", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/checkout/mcp.md", + "line": 859, + "section": "Checkout Capability - MCP Binding > Implementation", + "text": "Implementers **MUST** expose this as an MCP `tools/call` endpoint:", + "actor": "implementation", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "line": 354, + "section": "Buyer Consent Extension > Data dependencies", + "text": "Missing dependencies MUST be surfaced via the standard [Error Handling](../checkout/index.md#error-handling) flow.", + "actor": "buyer", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "line": 372, + "section": "Buyer Consent Extension > Normative requirements", + "text": "Omitting an advertised key within a submitted `consent` map MUST NOT be used to signal any value.", + "actor": "buyer", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/discount.md", + "line": 146, + "section": "Discount Extension > Operations", + "text": "Codes that are no longer valid at checkout time (e.g., expired, ineligible) SHOULD be communicated via `messages[]` using standard rejection codes.", + "actor": "extension", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/discount.md", + "line": 227, + "section": "Discount Extension > Eligibility Claims > Verification at Checkout", + "text": "At checkout completion, all remaining provisional claims **MUST** be resolved (see [Eligibility Verification at Completion](../checkout/index.md#eligibility-verification-at-completion)).", + "actor": "extension", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 260, + "section": "Fulfillment Extension > Destinations", + "text": "A request that includes `destinations[]` MUST also include the method's `type`.", + "actor": "extension", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 353, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "text": "A non-null `selected_destination_id` **MAY** carry an ID the Platform obtained from a Catalog response, a Location search or lookup, an earlier Checkout, or any other source the Business recognizes for that method.", + "actor": "extension", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 360, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "text": "**MUST** carry that same `selected_destination_id` value on the method; and", + "actor": "extension", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 361, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "text": "**MUST** include exactly one destination in that same method's `destinations[]` whose `id` equals it, typed as specified in [Destinations](#destinations) — so the response is self-describing whatever the ID's source.", + "actor": "extension", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 405, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "text": "**MUST** distinguish this option from its siblings", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 406, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "text": "**SHOULD** include method and speed (e.g., \"Express Shipping\", \"Curbside Pickup\")", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 407, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "text": "**MUST** be sufficient for buyer decision if `description` is absent", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 411, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "text": "**MUST NOT** repeat `title` or `total`—provides supplementary context only", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 412, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "text": "**SHOULD** include timing, carrier, or other decision-relevant details", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 413, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "text": "**SHOULD** be a complete phrase (e.g., \"Arrives Dec 12-15 via FedEx\")", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 414, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "text": "**MAY** be omitted if title is self-explanatory", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 418, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "text": "**MUST** be a standalone sentence explaining what, when, and where", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 419, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "text": "**SHOULD** be usable verbatim in platform dialogue (e.g., \"Pants available for pickup at Downtown Store today at 2pm\")", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 426, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "text": "they **MUST** preserve the method/option grouping", + "actor": "business", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 541, + "section": "Fulfillment Extension > Catalog Discovery > Methods", + "text": "Where a method states `availability`, consumers MUST use it for that method", + "actor": "extension", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 541, + "section": "Fulfillment Extension > Catalog Discovery > Methods", + "text": "Where a method states `availability`, consumers MUST NOT infer per-method availability from the variant-level value.", + "actor": "extension", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 549, + "section": "Fulfillment Extension > Catalog Discovery > Options", + "text": "A method MAY carry `options[]`, a representative subset of its fulfillment options — not an exhaustive list.", + "actor": "extension", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 555, + "section": "Fulfillment Extension > Catalog Discovery > Options", + "text": "A method MAY also carry none, surfacing only `type`, `description`, and `availability`; options are nested directly under the method, with no group layer (unlike checkout `methods[].groups[].options[]`).", + "actor": "extension", + "confidence": 0.5 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 724, + "section": "Fulfillment Extension > Configuration > Platform Profile", + "text": "A party that does not expose catalog discovery MAY narrow `extends` to `\"dev.ucp.shopping.checkout\"` (string form) or to a single-element array.", + "actor": "platform", + "confidence": 0.5 + } + ], + "actor_unresolved": [ + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 140, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "text": "Parameters **SHOULD** use either `ep` or `ep_cart` prefixes to avoid namespace pollution and clearly distinguish ECaP parameters from business-specific query parameters:" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 152, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "text": "**MAY** be empty if no delegations are needed." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 152, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "text": "**SHOULD** be a subset of `config.delegate` from the embedded service binding." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 162, + "section": "Cart Capability - EP Binding > Transport & Messaging", + "text": "The `ucp.version` in all responses **MUST** echo the `ep_version` negotiated during session initialization and confirmed by the host in the `ep.cart.ready` response." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 162, + "section": "Cart Capability - EP Binding > Transport & Messaging", + "text": "The version is session-bound — it **MUST NOT** change for the duration of the ECaP session." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 185, + "section": "Cart Capability - EP Binding > Message API Reference > Message Categories > Core Messages", + "text": "Core messages are defined by the ECaP specification and **MUST** be supported by all implementations." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 200, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "Upon rendering, the Embedded Cart **MUST** broadcast readiness to the parent context using the `ep.cart.ready` message." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 209, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "**MUST** be a subset of both `ep_cart_delegate` (what host requested) and `config.delegate` from the cart response (what business allows)." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 243, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "The `version` confirms the negotiated `ep_version` and `status` **MUST** be `\"success\"`." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 251, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "The requested authorization data, can be in the form of an OAuth token, JWT, API keys, etc. **MUST** be set if `auth` is present in the request." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 251, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "**MUST NOT** be set if `upgrade` is present." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 270, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "Currently, this object only supports a `port` field, which **MUST** be a `MessagePort` object" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 270, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "Currently, this object only supports a `port` field, which **MUST** be transferred to the embedded cart context (e.g., with `{transfer: [port2]}` on the host's `iframe.contentWindow.postMessage()` call)" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 292, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "All subsequent messages **MUST** be sent only over the upgraded communication channel." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 298, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "The Embedded Cart **MUST NOT** send further messages after receiving a handshake error." + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 316, + "section": "Cart Capability - EP Binding > Message API Reference > Authentication > `ep.cart.auth`", + "text": "When error escalation is required, Embedded Cart **MUST** issue an `ep.cart.error` notification per the [session error pattern](../../embedded-protocol.md#session-error)." + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 81, + "section": "Cart Capability > Cart-to-Checkout Conversion", + "text": "When checkout is initialized via `cart_id`, the cart and checkout sessions SHOULD be linked for the duration of the checkout." + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 224, + "section": "Cart Capability > Operations > Cancel Cart", + "text": "Subsequent operations for this cart ID SHOULD return `not_found`." + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 267, + "section": "Cart Capability > Entities > Signals", + "text": "Signal values MUST NOT be buyer-asserted claims." + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 291, + "section": "Cart Capability > Entities > Total", + "text": "Taxes MAY be included where calculable." + }, + { + "file": "docs/specification/shopping/cart/mcp.md", + "line": 103, + "section": "Cart Capability - MCP Binding > Tools > Identifier Pattern", + "text": "The `cart` object in the request payload **MUST NOT** contain an `id` field." + }, + { + "file": "docs/specification/shopping/cart/rest.md", + "line": 76, + "section": "Cart Capability - REST Binding > Protocol Fundamentals > Content Types", + "text": "All request and response bodies **MUST** be valid JSON as specified in [RFC 8259](https://tools.ietf.org/html/rfc8259){ target=\"_blank\" }." + }, + { + "file": "docs/specification/shopping/cart/rest.md", + "line": 81, + "section": "Cart Capability - REST Binding > Protocol Fundamentals > Transport Security", + "text": "All REST endpoints **MUST** be served over HTTPS with minimum TLS version 1.3." + }, + { + "file": "docs/specification/shopping/cart/rest.md", + "line": 538, + "section": "Cart Capability - REST Binding > Security Considerations > Authentication", + "text": "When authentication is required, the REST transport **MAY** use:" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 54, + "section": "Catalog Capability > Key Concepts > Relationship to Checkout", + "text": "Responses can be session-specific and **SHOULD NOT** be reused across sessions without re-validation." + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 181, + "section": "Catalog Capability > Shared Entities > Context", + "text": "Eligibility and policy enforcement MUST occur at checkout time using binding transaction data." + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 203, + "section": "Catalog Capability > Shared Entities > Signals", + "text": "Signal values MUST NOT be buyer-asserted claims." + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 261, + "section": "Catalog Capability > Shared Entities > Media", + "text": "It **MAY** present such an item from `preview` and `name`, or omit it." + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 300, + "section": "Catalog Capability > Shared Entities > Media > External Video", + "text": "Before embedding, it **MUST** decline the item unless `url` is an absolute `https` URL without userinfo that is not same-site with the Platform." + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 357, + "section": "Catalog Capability > Actions", + "text": "A concrete Action-type contract **MAY** define stronger correlation for its instances." + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 368, + "section": "Catalog Capability > Actions", + "text": "Catalog defines no Action lifecycle, polling, or resume behavior; a concrete Action-type contract **MAY** define those behaviors for processing its instances." + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 504, + "section": "Catalog Capability > Messages and Error Handling > Common Scenarios > Identifiers Not Found", + "text": "The response MAY include informational messages indicating which identifiers were not found." + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "line": 37, + "section": "Catalog Lookup Capability > Operations", + "text": "MAY support SKU, handle, URL, etc." + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "line": 56, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Supported Identifiers", + "text": "Duplicate identifiers in the request MUST be deduplicated." + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "line": 56, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Supported Identifiers", + "text": "When multiple identifiers resolve to the same product, it MUST be returned once." + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "line": 68, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Client Correlation", + "text": "Variants without an `inputs` entry MUST NOT appear in lookup responses." + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "line": 128, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Resolution Behavior", + "text": "`variants` SHOULD contain the featured variant and other variants matching `product.selected`." + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "line": 131, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Resolution Behavior", + "text": "The requested variant MUST be the first element (featured)." + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "line": 154, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Option Selection > Input", + "text": "Each option name MUST appear at most once." + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "line": 164, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Option Selection > Output: Effective Selections", + "text": "The response MUST include `product.selected` when the product has configurable options — reflecting the effective selections after any relaxation when the request includes `selected`, or the featured variant's default selections otherwise." + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "line": 164, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Option Selection > Output: Effective Selections", + "text": "When the product has no configurable options, `selected` MAY be empty or omitted." + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "line": 181, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Option Selection > Output: Availability Signals", + "text": "Option values in the response SHOULD include availability signals relative to `product.selected`:" + }, + { + "file": "docs/specification/shopping/catalog/mcp.md", + "line": 404, + "section": "Catalog - MCP Binding > Tools > Lookup Response > Partial Success", + "text": "The response MAY include informational messages indicating which identifiers were not found." + }, + { + "file": "docs/specification/shopping/catalog/mcp.md", + "line": 795, + "section": "Catalog - MCP Binding > Conformance", + "text": "When the Lookup capability is advertised, both `lookup_catalog` and `get_product` tools MUST be available." + }, + { + "file": "docs/specification/shopping/catalog/mcp.md", + "line": 797, + "section": "Catalog - MCP Binding > Conformance", + "text": "Return successful result for lookup requests; unknown identifiers result in fewer products returned (MAY include informational `not_found` messages)." + }, + { + "file": "docs/specification/shopping/catalog/rest.md", + "line": 293, + "section": "Catalog - REST Binding > Endpoints > `POST /catalog/lookup` > Example: Partial Success (Some Identifiers Not Found)", + "text": "The response MAY include informational messages indicating which identifiers were not found." + }, + { + "file": "docs/specification/shopping/catalog/rest.md", + "line": 687, + "section": "Catalog - REST Binding > Conformance", + "text": "When the Lookup capability is advertised, both `/catalog/lookup` and `/catalog/product` MUST be available." + }, + { + "file": "docs/specification/shopping/catalog/rest.md", + "line": 691, + "section": "Catalog - REST Binding > Conformance", + "text": "Return HTTP 200 for lookup requests; unknown identifiers result in fewer products returned (MAY include informational `not_found` messages)." + }, + { + "file": "docs/specification/shopping/catalog/search.md", + "line": 40, + "section": "Catalog Search Capability > Search Inputs", + "text": "A valid search request MUST include at least one of: a `query` string, one or more `filters`, or an extension-defined input." + }, + { + "file": "docs/specification/shopping/checkout/a2a.md", + "line": 141, + "section": "Checkout Capability - A2A Binding > Checkout Functionality", + "text": "The checkout object **MUST** be returned as part of a `DataPart` object with key `a2a.ucp.checkout`." + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 392, + "section": "Checkout Capability - EP Binding > Requirements > Navigation Constraints", + "text": "**Permitted Exceptions:** The following navigation scenarios **MAY** be allowed when required for checkout completion:" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 400, + "section": "Checkout Capability - EP Binding > Requirements > Navigation Constraints", + "text": "These exceptions **SHOULD** return the user to the checkout flow upon completion." + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 409, + "section": "Checkout Capability - EP Binding > Transport & Messaging", + "text": "The `ucp.version` in all responses **MUST** echo the `ec_version` negotiated during session initialization and confirmed by the host in the `ec.ready` response." + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 409, + "section": "Checkout Capability - EP Binding > Transport & Messaging", + "text": "The version is session-bound — it **MUST NOT** change for the duration of the ECP session." + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 432, + "section": "Checkout Capability - EP Binding > Message API Reference > Message Categories > Core Messages", + "text": "Core messages are defined by the ECP specification and **MUST** be supported by all implementations." + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 475, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "**MUST** be a subset of both `ec_delegate` (what host requested) and `config.delegate` from the checkout response (what business allows)." + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 526, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "The `version` confirms the negotiated `ec_version` and `status` **MUST** be `\"success\"`." + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 536, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "The requested authorization data, can be in the form of an OAuth token, JWT, API keys, etc. **MUST** be set if `auth` is present in the request." + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 536, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "**MUST NOT** be set if `upgrade` is present." + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 561, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "Currently, this object only supports a `port` field, which **MUST** be a `MessagePort` object" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 561, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "Currently, this object only supports a `port` field, which **MUST** be transferred to the embedded checkout context (e.g., with `{transfer: [port2]}` on the host's `iframe.contentWindow.postMessage()` call)" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 583, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "All subsequent messages **MUST** be sent only over the upgraded communication channel." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 242, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "text": "**Ordering increment.** The sale basis **MAY** declare an [`increment`](../../overview/index.md#ordering-increment) — the ordering granularity, in steps, the Business sells in." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 242, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "text": "A revision **MUST** be returned as a revised line `quantity` with an explanatory `messages[]` entry" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 242, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "text": "such revisions **SHOULD** stay on the increment grid so subsequent Platform stepper edits from the revised value remain on-grid." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 291, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "text": "When the pricing basis is the sale basis, `unit_price` remains a catalog display comparator and MAY be omitted from lines." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 397, + "section": "Checkout Capability > Overview > Status Values", + "text": "The response **MUST NOT** contain `order`." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 515, + "section": "Checkout Capability > Overview > Error Handling", + "text": "When no resource exists to act on, messages SHOULD use `severity: \"unrecoverable\"`." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 643, + "section": "Checkout Capability > Overview > Error Handling > The `path` Field", + "text": "`path` **MUST** be an [RFC 9535](https://www.rfc-editor.org/rfc/rfc9535) JSONPath expression relative to the root of the UCP response object." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 670, + "section": "Checkout Capability > Overview > Error Handling > The `path` Field", + "text": "When multiple errors apply to the same field, each message **SHOULD** carry the most specific path applicable." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 677, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "text": "all accepted claims **MUST** be resolved before the transaction can complete." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 684, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "text": "Unrecognized or inapplicable claims **MUST NOT** block the checkout." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 684, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "text": "At completion, accepted claims that remain unverified **MUST** result in `type: \"error\"` with `code: \"eligibility_invalid\"` (see below)." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 793, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion > Example: resolving a claim with a verification Action", + "text": "With the claim resolved, the checkout **MAY** advance to `ready_for_complete`." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 816, + "section": "Checkout Capability > Overview > Warning Presentation", + "text": "**MUST**" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 816, + "section": "Checkout Capability > Overview > Warning Presentation", + "text": "**MUST**" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 817, + "section": "Checkout Capability > Overview > Warning Presentation", + "text": "**MAY**" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 817, + "section": "Checkout Capability > Overview > Warning Presentation", + "text": "**MUST**" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 818, + "section": "Checkout Capability > Overview > Warning Presentation", + "text": "**MAY**" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 818, + "section": "Checkout Capability > Overview > Warning Presentation", + "text": "**MUST NOT**" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 819, + "section": "Checkout Capability > Overview > Warning Presentation", + "text": "**MAY**" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 819, + "section": "Checkout Capability > Overview > Warning Presentation", + "text": "**MUST**" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 820, + "section": "Checkout Capability > Overview > Warning Presentation", + "text": "**MAY**" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 820, + "section": "Checkout Capability > Overview > Warning Presentation", + "text": "**SHOULD**" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 821, + "section": "Checkout Capability > Overview > Warning Presentation", + "text": "**MUST** via `continue_url`" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 831, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "text": "Warnings with `presentation: \"disclosure\"` carry notices — safety warnings, allergen declarations, compliance content, etc. — that **MUST** follow the prescribed rendering contract below." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 847, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "text": "Warnings with `presentation: \"disclosure\"` **SHOULD** be given rendering priority over notices." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 949, + "section": "Checkout Capability > Continue URL > Availability", + "text": "For terminal states (`completed`, `canceled`), `continue_url` **SHOULD** be omitted." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 957, + "section": "Checkout Capability > Continue URL > Format", + "text": "The `continue_url` **MUST** be an absolute HTTPS URL" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 957, + "section": "Checkout Capability > Continue URL > Format", + "text": "The `continue_url` **SHOULD** preserve checkout state for seamless handoff." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1109, + "section": "Checkout Capability > Operations > Complete Checkout", + "text": "A genuinely new Complete Checkout operation after the Checkout returns to `ready_for_complete` **MUST** use a fresh idempotency key, even if the payload is unchanged." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1120, + "section": "Checkout Capability > Operations > Complete Checkout", + "text": "At the time of order persistence, fields from `Checkout` **MAY** be used to construct the order representation (i.e. information like `line_items`, `fulfillment` will be used to create the initial order representation)." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1131, + "section": "Checkout Capability > Operations > Cancel Checkout", + "text": "Any checkout session with a status that is not equal to `completed` or `canceled` **SHOULD** be cancelable." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1157, + "section": "Checkout Capability > Entities > Context", + "text": "Eligibility and policy enforcement MUST occur at checkout time using binding transaction data." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1318, + "section": "Checkout Capability > Entities > Total > Rendering Contract", + "text": "Well-known types have default display labels as fallback (see table below); unknown types MUST include `display_text`." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1323, + "section": "Checkout Capability > Entities > Total > Rendering Contract", + "text": "Exactly one `type: \"subtotal\"` MUST be present." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1324, + "section": "Checkout Capability > Entities > Total > Rendering Contract", + "text": "Exactly one `type: \"total\"` MUST be present." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1353, + "section": "Checkout Capability > Entities > Total > Well-Known Types", + "text": "The sign convention for well-known types is schema-enforced: subtractive types (discount, items_discount) MUST have negative amounts" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1353, + "section": "Checkout Capability > Entities > Total > Well-Known Types", + "text": "additive types (subtotal, fulfillment, tax, fee) MUST have non-negative amounts." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1359, + "section": "Checkout Capability > Entities > Total > Well-Known Types", + "text": "Unknown types MUST include `display_text` (schema-enforced) and the sign on the amount is self-describing." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1365, + "section": "Checkout Capability > Entities > Total > Repeating Types", + "text": "All types except `subtotal` and `total` MAY appear multiple times — for example, multi-jurisdiction tax lines or itemized fees." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1370, + "section": "Checkout Capability > Entities > Total > Sub-Lines (`lines`)", + "text": "Each top-level entry MAY include a `lines` array." + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1374, + "section": "Checkout Capability > Entities > Total > Sub-Lines (`lines`)", + "text": "**Invariant:** `sum(lines[].amount)` MUST equal the parent entry's `amount`." + }, + { + "file": "docs/specification/shopping/checkout/mcp.md", + "line": 120, + "section": "Checkout Capability - MCP Binding > Tools > Identifier Pattern", + "text": "The `checkout` object in the request payload **MUST NOT** contain an `id` field." + }, + { + "file": "docs/specification/shopping/checkout/mcp.md", + "line": 782, + "section": "Checkout Capability - MCP Binding > Message Signing > Response Signing", + "text": "Response signatures are **RECOMMENDED** for:" + }, + { + "file": "docs/specification/shopping/checkout/mcp.md", + "line": 786, + "section": "Checkout Capability - MCP Binding > Message Signing > Response Signing", + "text": "Response signatures are **OPTIONAL** for:" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "line": 71, + "section": "Checkout Capability - REST Binding > Protocol Fundamentals > Content Types", + "text": "All request and response bodies **MUST** be valid JSON as specified in [RFC 8259](https://tools.ietf.org/html/rfc8259){ target=\"_blank\" }." + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "line": 76, + "section": "Checkout Capability - REST Binding > Protocol Fundamentals > Transport Security", + "text": "All REST endpoints **MUST** be served over HTTPS with minimum TLS version 1.3." + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "line": 1410, + "section": "Checkout Capability - REST Binding > Message Signing > Request Signing", + "text": "When HTTP Message Signatures are used, requests **MUST** include valid `Signature-Input` and `Signature` headers (and `Content-Digest` when a body is present) per RFC 9421:" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "line": 1442, + "section": "Checkout Capability - REST Binding > Message Signing > Response Signing", + "text": "Response signatures are **RECOMMENDED** for:" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "line": 1446, + "section": "Checkout Capability - REST Binding > Message Signing > Response Signing", + "text": "Response signatures are **OPTIONAL** for:" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "line": 1469, + "section": "Checkout Capability - REST Binding > Security Considerations > Authentication", + "text": "When authentication is required, the REST transport **MAY** use:" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 34, + "section": "Order Capability > Overview > Key Concepts", + "text": "**MUST** include all line items that ever existed on the order regardless of edits or alterations" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 374, + "section": "Order Capability > Example: count-sold, measure-priced settlement", + "text": "When the price settles against an actual measurement, the adjustment **MUST** carry the settled `measure`" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 374, + "section": "Order Capability > Example: count-sold, measure-priced settlement", + "text": "its unit identity **MUST** match the pricing basis (no conversion), and a pure price settlement uses `quantity: 0` so the count is untouched. (A settled `measure` is Business-recorded fact" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 662, + "section": "Order Capability > Operations > Guidelines", + "text": "**MUST** include `UCP-Agent` header with profile URL on all requests" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 663, + "section": "Order Capability > Operations > Guidelines", + "text": "**SHOULD** rely on webhooks (see [Events](#events)) as the primary order update channel and use Get Order for reconciliation or on-demand retrieval" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 665, + "section": "Order Capability > Operations > Guidelines", + "text": "**SHOULD** treat order data as ephemeral and discard it when no longer needed for active commerce flows" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 670, + "section": "Order Capability > Operations > Guidelines", + "text": "**MUST** authenticate requests to order data before returning a response (see [Authorization](#authorization))" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 729, + "section": "Order Capability > Events > Webhook Signature Verification", + "text": "Webhook payloads **MUST** be signed by the business and verified by the platform to ensure authenticity and integrity." + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 827, + "section": "Order Capability > Events > Guidelines", + "text": "**MUST** respond quickly with a 2xx HTTP status code to acknowledge webhook receipt; process events asynchronously after responding" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 832, + "section": "Order Capability > Events > Guidelines", + "text": "**MUST** include `UCP-Agent` header with profile URL for signer identification" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 833, + "section": "Order Capability > Events > Guidelines", + "text": "**MUST** sign all webhook payloads per the [Message Signatures](../../signatures.md) specification using RFC 9421 headers (`Signature`, `Signature-Input`, `Content-Digest`)" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 836, + "section": "Order Capability > Events > Guidelines", + "text": "**MUST** send \"Order created\" event with fully populated order entity" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 837, + "section": "Order Capability > Events > Guidelines", + "text": "**MUST** send full order entity on updates (not incremental deltas)" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 838, + "section": "Order Capability > Events > Guidelines", + "text": "**MUST** retry failed webhook deliveries" + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 839, + "section": "Order Capability > Events > Guidelines", + "text": "**MUST** send retries with the original `Webhook-Id` and `Webhook-Timestamp`; a retry redelivers the same event, and platforms deduplicate on `Webhook-Id` and order deliveries by `Webhook-Timestamp`" + }, + { + "file": "docs/specification/shopping/order/mcp.md", + "line": 291, + "section": "Order Capability - MCP Binding > Conformance", + "text": "**MUST** include `meta.ucp-agent.profile` on all requests" + }, + { + "file": "docs/specification/shopping/order/mcp.md", + "line": 292, + "section": "Order Capability - MCP Binding > Conformance", + "text": "**MUST** check the `messages` array in responses before accessing order data" + }, + { + "file": "docs/specification/shopping/order/mcp.md", + "line": 293, + "section": "Order Capability - MCP Binding > Conformance", + "text": "**SHOULD** delegate to the business via `permalink_url` for the authoritative order experience - the business site is the source of truth for order details and post-purchase operations" + }, + { + "file": "docs/specification/shopping/order/mcp.md", + "line": 299, + "section": "Order Capability - MCP Binding > Conformance", + "text": "**MUST** implement the `get_order` tool per the [OpenRPC schema](site:services/shopping/mcp.openrpc.json)" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "line": 68, + "section": "Order Capability - REST Binding > Protocol Fundamentals > Content Types", + "text": "All response bodies **MUST** be valid JSON as specified in [RFC 8259](https://tools.ietf.org/html/rfc8259){ target=\"_blank\" }." + }, + { + "file": "docs/specification/shopping/order/rest.md", + "line": 73, + "section": "Order Capability - REST Binding > Protocol Fundamentals > Transport Security", + "text": "All REST endpoints **MUST** be served over HTTPS with minimum TLS version 1.3." + }, + { + "file": "docs/specification/shopping/order/rest.md", + "line": 249, + "section": "Order Capability - REST Binding > Conformance", + "text": "**MUST** include `UCP-Agent` header with profile URL on all requests" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "line": 250, + "section": "Order Capability - REST Binding > Conformance", + "text": "**MUST** check the `messages` array in responses before accessing order data" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "line": 251, + "section": "Order Capability - REST Binding > Conformance", + "text": "**SHOULD** delegate to the business via `permalink_url` for the authoritative order experience - the business site is the source of truth for order details and post-purchase operations" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "line": 257, + "section": "Order Capability - REST Binding > Conformance", + "text": "**MUST** serve all endpoints over HTTPS with TLS 1.3+" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "line": 258, + "section": "Order Capability - REST Binding > Conformance", + "text": "**SHOULD** sign responses per the [Message Signatures](../../signatures.md) specification" + } + ], + "annotation_as_obligation": [ + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1078, + "section": "Checkout Capability > Operations > Update Checkout", + "text": "The platform is **REQUIRED** to send the entire checkout resource containing any data updates to write-only data fields.", + "annotation": "REQUIRED", + "level": "MUST" + }, + { + "file": "docs/specification/shopping/checkout/mcp.md", + "line": 782, + "section": "Checkout Capability - MCP Binding > Message Signing > Response Signing", + "text": "Response signatures are **RECOMMENDED** for:", + "annotation": "RECOMMENDED", + "level": "SHOULD" + }, + { + "file": "docs/specification/shopping/checkout/mcp.md", + "line": 786, + "section": "Checkout Capability - MCP Binding > Message Signing > Response Signing", + "text": "Response signatures are **OPTIONAL** for:", + "annotation": "OPTIONAL", + "level": "MAY" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "line": 1442, + "section": "Checkout Capability - REST Binding > Message Signing > Response Signing", + "text": "Response signatures are **RECOMMENDED** for:", + "annotation": "RECOMMENDED", + "level": "SHOULD" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "line": 1446, + "section": "Checkout Capability - REST Binding > Message Signing > Response Signing", + "text": "Response signatures are **OPTIONAL** for:", + "annotation": "OPTIONAL", + "level": "MAY" + } + ], + "annotations_excluded": [ + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 145, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "text": "`ep_version` (string, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 147, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "text": "`ep_auth` (string, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 149, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "text": "`ep_color_scheme` (string, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 152, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "text": "`ep_cart_delegate` (string, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 209, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "`delegate` (array of strings, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 214, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "`auth` (object, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 243, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "`ucp` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 246, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "`upgrade` (object, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 251, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "`credential` (string, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 334, + "section": "Cart Capability - EP Binding > Message API Reference > Lifecycle Messages > `ep.cart.start`", + "text": "`cart` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 369, + "section": "Cart Capability - EP Binding > Message API Reference > Lifecycle Messages > `ep.cart.complete`", + "text": "`cart` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 405, + "section": "Cart Capability - EP Binding > Message API Reference > State Change Messages > `ep.cart.line_items.change`", + "text": "`cart` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 433, + "section": "Cart Capability - EP Binding > Message API Reference > State Change Messages > `ep.cart.buyer.change`", + "text": "`cart` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 461, + "section": "Cart Capability - EP Binding > Message API Reference > State Change Messages > `ep.cart.messages.change`", + "text": "`cart` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 195, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "text": "`ec_version` (string, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 200, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "text": "`ec_auth` (string, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 202, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "text": "`ec_delegate` (string, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 205, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "text": "`ec_color_scheme` (string, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 475, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "`delegate` (array of strings, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 480, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "`auth` (object, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 526, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "`ucp` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 531, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "`upgrade` (object, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 536, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "`credential` (string, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 540, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "`checkout` (object, **OPTIONAL**):", + "annotation": "OPTIONAL" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 686, + "section": "Checkout Capability - EP Binding > Message API Reference > Lifecycle Messages > `ec.start`", + "text": "`checkout` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 725, + "section": "Checkout Capability - EP Binding > Message API Reference > Lifecycle Messages > `ec.complete`", + "text": "`checkout` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 762, + "section": "Checkout Capability - EP Binding > Message API Reference > State Change Messages > `ec.line_items.change`", + "text": "`checkout` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 790, + "section": "Checkout Capability - EP Binding > Message API Reference > State Change Messages > `ec.buyer.change`", + "text": "`checkout` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 818, + "section": "Checkout Capability - EP Binding > Message API Reference > State Change Messages > `ec.messages.change`", + "text": "`checkout` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 865, + "section": "Checkout Capability - EP Binding > Message API Reference > State Change Messages > `ec.totals.change`", + "text": "`checkout` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 914, + "section": "Checkout Capability - EP Binding > Message API Reference > State Change Messages > `ec.payment.change`", + "text": "`checkout` (object, **REQUIRED**):", + "annotation": "REQUIRED" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 1460, + "section": "Checkout Capability - EP Binding > Window Extension > Window Message API Reference > `ec.window.open_request`", + "text": "`url` (string, uri, **REQUIRED**):", + "annotation": "REQUIRED" + } + ], + "candidates_without_emphasis": [], + "compounds_not_split": [ + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1376, + "section": "Checkout Capability > Entities > Total > Sub-Lines (`lines`)", + "text": "The business controls what MUST be rendered (top-level entries) versus what MAY be optionally surfaced (sub-lines).", + "levels": [ + "MUST", + "MAY" + ] + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 366, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "text": "The Business **MUST NOT** silently substitute another destination: it **MUST NOT** return a different `selected_destination_id`, and **MUST NOT** keep the submitted ID while returning a destination that describes another location.", + "levels": [ + "MUST NOT", + "MUST NOT", + "MUST NOT" + ] + } + ], + "duplicate_requirements": [ + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 131, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "text": "Before loading the embedded context, the host **SHOULD**:", + "text_digest": "40901b2bee", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0032", + "REQ-SHOPPING-CHECKOUT-0154" + ], + "locations": [ + "docs/specification/shopping/cart/embedded.md:131", + "docs/specification/shopping/checkout/embedded.md:181" + ] + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 246, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "When present, host **MUST NOT** include `credential` — the channel will be re-established and any credential sent here will be discarded.", + "text_digest": "5e3413cd0d", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0044", + "REQ-SHOPPING-CHECKOUT-0192" + ], + "locations": [ + "docs/specification/shopping/cart/embedded.md:246", + "docs/specification/shopping/checkout/embedded.md:531" + ] + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 251, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "The requested authorization data, can be in the form of an OAuth token, JWT, API keys, etc. **MUST** be set if `auth` is present in the request.", + "text_digest": "abdc68d4ce", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0045", + "REQ-SHOPPING-CHECKOUT-0193" + ], + "locations": [ + "docs/specification/shopping/cart/embedded.md:251", + "docs/specification/shopping/checkout/embedded.md:536" + ] + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 251, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "**MUST NOT** be set if `upgrade` is present.", + "text_digest": "8c8a34c733", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0046", + "REQ-SHOPPING-CHECKOUT-0194" + ], + "locations": [ + "docs/specification/shopping/cart/embedded.md:251", + "docs/specification/shopping/checkout/embedded.md:536" + ] + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 270, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "Currently, this object only supports a `port` field, which **MUST** be a `MessagePort` object", + "text_digest": "eb3704265c", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0048", + "REQ-SHOPPING-CHECKOUT-0196" + ], + "locations": [ + "docs/specification/shopping/cart/embedded.md:270", + "docs/specification/shopping/checkout/embedded.md:561" + ] + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 292, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "All subsequent messages **MUST** be sent only over the upgraded communication channel.", + "text_digest": "a809664137", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0051", + "REQ-SHOPPING-CHECKOUT-0199" + ], + "locations": [ + "docs/specification/shopping/cart/embedded.md:292", + "docs/specification/shopping/checkout/embedded.md:583" + ] + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 298, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "If the host cannot complete the handshake (e.g., origin validation failure or protocol state violation), it **MUST** respond with an `error_response` result.", + "text_digest": "b4ddfaed6e", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0052", + "REQ-SHOPPING-CHECKOUT-0201" + ], + "locations": [ + "docs/specification/shopping/cart/embedded.md:298", + "docs/specification/shopping/checkout/embedded.md:630" + ] + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 298, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "The host **MUST** tear down the embedded context", + "text_digest": "dfcef5c6f2", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0053", + "REQ-SHOPPING-CHECKOUT-0202" + ], + "locations": [ + "docs/specification/shopping/cart/embedded.md:298", + "docs/specification/shopping/checkout/embedded.md:652" + ] + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 298, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "The host **MAY** redirect the buyer to `continue_url` if present.", + "text_digest": "c45fb9f3f1", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0054", + "REQ-SHOPPING-CHECKOUT-0203" + ], + "locations": [ + "docs/specification/shopping/cart/embedded.md:298", + "docs/specification/shopping/checkout/embedded.md:652" + ] + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 267, + "section": "Cart Capability > Entities > Signals", + "text": "Signal values MUST NOT be buyer-asserted claims.", + "text_digest": "d17ebc6153", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0027", + "REQ-SHOPPING-CATALOG-0019" + ], + "locations": [ + "docs/specification/shopping/cart/index.md:267", + "docs/specification/shopping/catalog/index.md:203" + ] + }, + { + "file": "docs/specification/shopping/cart/mcp.md", + "line": 68, + "section": "Cart Capability - MCP Binding > Protocol Fundamentals > Request Metadata", + "text": "MCP clients **MUST** include a `meta` object in every request containing protocol metadata:", + "text_digest": "7d9d798bfd", + "copies": 4, + "ids": [ + "REQ-SHOPPING-CART-0058", + "REQ-SHOPPING-CATALOG-0036", + "REQ-SHOPPING-CHECKOUT-0229", + "REQ-SHOPPING-ORDER-0027" + ], + "locations": [ + "docs/specification/shopping/cart/mcp.md:68", + "docs/specification/shopping/catalog/mcp.md:64", + "docs/specification/shopping/checkout/mcp.md:82", + "docs/specification/shopping/order/mcp.md:61" + ] + }, + { + "file": "docs/specification/shopping/cart/mcp.md", + "line": 91, + "section": "Cart Capability - MCP Binding > Protocol Fundamentals > Request Metadata", + "text": "Platforms **MAY** include additional metadata fields.", + "text_digest": "160daf898a", + "copies": 3, + "ids": [ + "REQ-SHOPPING-CART-0059", + "REQ-SHOPPING-CHECKOUT-0230", + "REQ-SHOPPING-ORDER-0028" + ], + "locations": [ + "docs/specification/shopping/cart/mcp.md:91", + "docs/specification/shopping/checkout/mcp.md:106", + "docs/specification/shopping/order/mcp.md:84" + ] + }, + { + "file": "docs/specification/shopping/cart/mcp.md", + "line": 651, + "section": "Cart Capability - MCP Binding > Conformance", + "text": "A conforming MCP transport implementation **MUST**:", + "text_digest": "748fc7ead3", + "copies": 3, + "ids": [ + "REQ-SHOPPING-CART-0061", + "REQ-SHOPPING-CATALOG-0039", + "REQ-SHOPPING-CHECKOUT-0237" + ], + "locations": [ + "docs/specification/shopping/cart/mcp.md:651", + "docs/specification/shopping/catalog/mcp.md:792", + "docs/specification/shopping/checkout/mcp.md:807" + ] + }, + { + "file": "docs/specification/shopping/cart/rest.md", + "line": 76, + "section": "Cart Capability - REST Binding > Protocol Fundamentals > Content Types", + "text": "All request and response bodies **MUST** be valid JSON as specified in [RFC 8259](https://tools.ietf.org/html/rfc8259){ target=\"_blank\" }.", + "text_digest": "017f445b50", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0062", + "REQ-SHOPPING-CHECKOUT-0241" + ], + "locations": [ + "docs/specification/shopping/cart/rest.md:76", + "docs/specification/shopping/checkout/rest.md:71" + ] + }, + { + "file": "docs/specification/shopping/cart/rest.md", + "line": 81, + "section": "Cart Capability - REST Binding > Protocol Fundamentals > Transport Security", + "text": "All REST endpoints **MUST** be served over HTTPS with minimum TLS version 1.3.", + "text_digest": "86f31bc40b", + "copies": 3, + "ids": [ + "REQ-SHOPPING-CART-0063", + "REQ-SHOPPING-CHECKOUT-0242", + "REQ-SHOPPING-ORDER-0035" + ], + "locations": [ + "docs/specification/shopping/cart/rest.md:81", + "docs/specification/shopping/checkout/rest.md:76", + "docs/specification/shopping/order/rest.md:73" + ] + }, + { + "file": "docs/specification/shopping/cart/rest.md", + "line": 538, + "section": "Cart Capability - REST Binding > Security Considerations > Authentication", + "text": "When authentication is required, the REST transport **MAY** use:", + "text_digest": "9655f6d29f", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CART-0064", + "REQ-SHOPPING-CHECKOUT-0251" + ], + "locations": [ + "docs/specification/shopping/cart/rest.md:538", + "docs/specification/shopping/checkout/rest.md:1469" + ] + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 181, + "section": "Catalog Capability > Shared Entities > Context", + "text": "Businesses SHOULD use these values when verified inputs (e.g., shipping address) are absent", + "text_digest": "35b444ee45", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CATALOG-0013", + "REQ-SHOPPING-CHECKOUT-0121" + ], + "locations": [ + "docs/specification/shopping/catalog/index.md:181", + "docs/specification/shopping/checkout/index.md:1157" + ] + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 181, + "section": "Catalog Capability > Shared Entities > Context", + "text": "Businesses MAY ignore or down-rank them if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls).", + "text_digest": "e137bb0b98", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CATALOG-0014", + "REQ-SHOPPING-CHECKOUT-0122" + ], + "locations": [ + "docs/specification/shopping/catalog/index.md:181", + "docs/specification/shopping/checkout/index.md:1157" + ] + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 181, + "section": "Catalog Capability > Shared Entities > Context", + "text": "Eligibility and policy enforcement MUST occur at checkout time using binding transaction data.", + "text_digest": "d647a85835", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CATALOG-0015", + "REQ-SHOPPING-CHECKOUT-0123" + ], + "locations": [ + "docs/specification/shopping/catalog/index.md:181", + "docs/specification/shopping/checkout/index.md:1157" + ] + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 222, + "section": "Catalog Capability > Shared Entities > Product", + "text": "Platforms **SHOULD** treat the first media item they present as featured.", + "text_digest": "def47e598c", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CATALOG-0021", + "REQ-SHOPPING-CATALOG-0023" + ], + "locations": [ + "docs/specification/shopping/catalog/index.md:222", + "docs/specification/shopping/catalog/index.md:238" + ] + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 504, + "section": "Catalog Capability > Messages and Error Handling > Common Scenarios > Identifiers Not Found", + "text": "The response MAY include informational messages indicating which identifiers were not found.", + "text_digest": "440c8529d2", + "copies": 5, + "ids": [ + "REQ-SHOPPING-CATALOG-0035", + "REQ-SHOPPING-CATALOG-0037", + "REQ-SHOPPING-CATALOG-0038", + "REQ-SHOPPING-CATALOG-0042", + "REQ-SHOPPING-CATALOG-0043" + ], + "locations": [ + "docs/specification/shopping/catalog/index.md:504", + "docs/specification/shopping/catalog/mcp.md:404", + "docs/specification/shopping/catalog/mcp.md:740", + "docs/specification/shopping/catalog/rest.md:293", + "docs/specification/shopping/catalog/rest.md:633" + ] + }, + { + "file": "docs/specification/shopping/checkout/mcp.md", + "line": 782, + "section": "Checkout Capability - MCP Binding > Message Signing > Response Signing", + "text": "Response signatures are **RECOMMENDED** for:", + "text_digest": "833d001a11", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CHECKOUT-0235", + "REQ-SHOPPING-CHECKOUT-0249" + ], + "locations": [ + "docs/specification/shopping/checkout/mcp.md:782", + "docs/specification/shopping/checkout/rest.md:1442" + ] + }, + { + "file": "docs/specification/shopping/checkout/mcp.md", + "line": 786, + "section": "Checkout Capability - MCP Binding > Message Signing > Response Signing", + "text": "Response signatures are **OPTIONAL** for:", + "text_digest": "eb1ea646bd", + "copies": 2, + "ids": [ + "REQ-SHOPPING-CHECKOUT-0236", + "REQ-SHOPPING-CHECKOUT-0250" + ], + "locations": [ + "docs/specification/shopping/checkout/mcp.md:786", + "docs/specification/shopping/checkout/rest.md:1446" + ] + } + ], + "empty_after_split": [], + "multi_obligation_sentences": [ + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 270, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "Currently, this object only supports a `port` field, which **MUST** be a `MessagePort` object, and **MUST** be transferred to the embedded cart context (e.g., with `{transfer: [port2]}` on the host's `iframe.contentWindow.postMessage()` call):", + "levels": [ + "MUST", + "MUST" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "line": 298, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "text": "The host **MUST** tear down the embedded context and **MAY** redirect the buyer to `continue_url` if present.", + "levels": [ + "MUST", + "MAY" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 67, + "section": "Cart Capability > Cart-to-Checkout Conversion", + "text": "Because the cart checkout extension composes onto the base Checkout schema, `line_items` remains a required request field; the platform MUST include line_items and SHOULD set it to an empty array (`\"line_items\": []`). array (`\"line_items\": []`).", + "levels": [ + "MUST", + "SHOULD" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/cart/index.md", + "line": 67, + "section": "Cart Capability > Cart-to-Checkout Conversion", + "text": "The business MUST use the cart contents and MUST ignore overlapping fields in the checkout payload.", + "levels": [ + "MUST", + "MUST" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 181, + "section": "Catalog Capability > Shared Entities > Context", + "text": "Businesses SHOULD use these values when verified inputs (e.g., shipping address) are absent, and MAY ignore or down-rank them if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls).", + "levels": [ + "SHOULD", + "MAY" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "line": 194, + "section": "Catalog Capability > Shared Entities > Context", + "text": "When `context.eligibility` claims are present, Businesses that accept them **MAY** adjust `price` / `list_price` directly for strikethrough display and **MAY** use `messages` with `code: \"eligibility_benefit\"` to attribute the adjustment to a specific claim.", + "levels": [ + "MAY", + "MAY" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "line": 76, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Batch Size", + "text": "Implementations MAY enforce a maximum batch size and MUST reject requests exceeding their limit with an appropriate error (HTTP 400 `request_too_large` for REST, JSON-RPC `-32602` for MCP).", + "levels": [ + "MAY", + "MUST" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/catalog/search.md", + "line": 47, + "section": "Catalog Search Capability > Search Inputs", + "text": "Implementations MUST validate that incoming requests contain at least one recognized input and SHOULD reject empty or invalid requests with an appropriate error.", + "levels": [ + "MUST", + "SHOULD" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 322, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL > Delegation Negotiation", + "text": "The business **SHOULD NOT** accept delegations not present in `config.delegate` and **MUST** confirm accepted delegations in `ec.ready`", + "levels": [ + "SHOULD NOT", + "MUST" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 561, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "Currently, this object only supports a `port` field, which **MUST** be a `MessagePort` object, and **MUST** be transferred to the embedded checkout context (e.g., with `{transfer: [port2]}` on the host's `iframe.contentWindow.postMessage()` call):", + "levels": [ + "MUST", + "MUST" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "line": 652, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "text": "The host **MUST** tear down the embedded context and **MAY** redirect the buyer to `continue_url` if present.", + "levels": [ + "MUST", + "MAY" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 242, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "text": "A revision **MUST** be returned as a revised line `quantity` with an explanatory `messages[]` entry; the Business **MUST NOT** silently reinterpret the requested quantity.", + "levels": [ + "MUST", + "MUST NOT" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 242, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "text": "The Business **MAY** also revise a quantity for its own reasons (for example, limited stock); such revisions **SHOULD** stay on the increment grid so subsequent Platform stepper edits from the revised value remain on-grid.", + "levels": [ + "MAY", + "SHOULD" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 450, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "text": "The Platform **MAY** repeat Get Checkout with bounded backoff set by the Action contract or Platform policy, and **MUST** stop repeated requests at `expires_at`.", + "levels": [ + "MAY", + "MUST" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 544, + "section": "Checkout Capability > Overview > Error Handling > Error Processing Algorithm", + "text": "Businesses **SHOULD** surface such messages as early as possible, and platforms **SHOULD** prioritize resolving recoverable errors before initiating handoff.", + "levels": [ + "SHOULD", + "SHOULD" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 677, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "text": "Businesses **MAY** act on recognized claims during the session (adjusting pricing, granting product access, applying provisional discounts), but all accepted claims **MUST** be resolved before the transaction can complete.", + "levels": [ + "MAY", + "MUST" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 684, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "text": "Businesses **SHOULD** notify the buyer via `messages` with `type: \"warning\"` when a claim is not accepted, and **MAY** use `type: \"info\"` to explain the effects of accepted claims.", + "levels": [ + "SHOULD", + "MAY" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 825, + "section": "Checkout Capability > Overview > Warning Presentation > `notice` (default)", + "text": "Platforms **MAY** render notices in a banner, tray, or toast, and **MAY** allow the buyer to dismiss them.", + "levels": [ + "MAY", + "MAY" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 957, + "section": "Checkout Capability > Continue URL > Format", + "text": "The `continue_url` **MUST** be an absolute HTTPS URL and **SHOULD** preserve checkout state for seamless handoff.", + "levels": [ + "MUST", + "SHOULD" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1109, + "section": "Checkout Capability > Operations > Complete Checkout", + "text": "If the Platform does not receive a response to Complete Checkout, it **SHOULD** use Get Checkout with bounded backoff to obtain the current state and **MUST** stop at `expires_at`.", + "levels": [ + "SHOULD", + "MUST" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1157, + "section": "Checkout Capability > Entities > Context", + "text": "Businesses SHOULD use these values when verified inputs (e.g., shipping address) are absent, and MAY ignore or down-rank them if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls).", + "levels": [ + "SHOULD", + "MAY" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "line": 1353, + "section": "Checkout Capability > Entities > Total > Well-Known Types", + "text": "The sign convention for well-known types is schema-enforced: subtractive types (discount, items_discount) MUST have negative amounts; additive types (subtotal, fulfillment, tax, fee) MUST have non-negative amounts.", + "levels": [ + "MUST", + "MUST" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "line": 401, + "section": "Buyer Consent Extension > Normative requirements", + "text": "**Persistence and reversibility.** Platforms MAY persist a buyer's prior preferences (`source: \"platform\"`) across interactions with the same business and MAY suppress re-presentation of unchanged values.", + "levels": [ + "MAY", + "MAY" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 308, + "section": "Fulfillment Extension > Destinations > Business Location Destination", + "text": "The Business **MUST** return `type: \"business_location\"`, `id`, and its Buyer-facing `name`, and **MAY** return its Postal Address in `address`.", + "levels": [ + "MUST", + "MAY" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 374, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "text": "When the Business cannot accept a `selected_destination_id` submitted on [Update Checkout](../checkout/index.md#update-checkout) — the ID is not recognized for that method, or revalidation fails — it follows the general behavior for a rejected Update: it **MUST** leave the current Checkout unchanged and **MUST** return that Checkout with an error Message with `severity: \"recoverable\"` whose `path` selects the attempted method's `selected_destination_id` (for example `$.fulfillment.methods[0].selected_destination_id`).", + "levels": [ + "MUST", + "MUST" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 426, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "text": "Platforms **SHOULD** preserve that order, but **MAY** re-order it (e.g. to match known buyer preferences or surface-specific ranking); they **MUST** preserve the method/option grouping", + "levels": [ + "SHOULD", + "MAY", + "MUST" + ], + "parts": 3 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 541, + "section": "Fulfillment Extension > Catalog Discovery > Methods", + "text": "Where a method states `availability`, consumers MUST use it for that method and MUST NOT infer per-method availability from the variant-level value.", + "levels": [ + "MUST", + "MUST NOT" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 600, + "section": "Fulfillment Extension > Catalog Discovery > Location and method: `context` and `filters`", + "text": "Platforms **SHOULD** provide one or the other, not both; if both are present, a business **SHOULD** use the more specific — typically `location`.", + "levels": [ + "SHOULD", + "SHOULD" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 800, + "section": "Fulfillment Extension > Configuration > Method Types", + "text": "Presentation is method-agnostic: platforms **SHOULD** present every method, rendering `description` and `availability` regardless of its `type` (see [Rendering](#rendering)), and **SHOULD NOT** omit a method solely because they do not recognize its `type`.", + "levels": [ + "SHOULD", + "SHOULD NOT" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "line": 807, + "section": "Fulfillment Extension > Configuration > Method Types", + "text": "A business **SHOULD** model same-scope variation (e.g. Standard vs Express) as `options`, and **SHOULD NOT** emit multiple methods that differ only in option-level detail.", + "levels": [ + "SHOULD", + "SHOULD NOT" + ], + "parts": 2 + }, + { + "file": "docs/specification/shopping/order/index.md", + "line": 374, + "section": "Order Capability > Example: count-sold, measure-priced settlement", + "text": "When the price settles against an actual measurement, the adjustment **MUST** carry the settled `measure`; its unit identity **MUST** match the pricing basis (no conversion), and a pure price settlement uses `quantity: 0` so the count is untouched. (A settled `measure` is Business-recorded fact;", + "levels": [ + "MUST", + "MUST" + ], + "parts": 2 + } + ], + "rfc2119_boilerplate": [] + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + } +} diff --git a/requirements/catalog/history.json b/requirements/catalog/history.json new file mode 100644 index 0000000..0e5c19a --- /dev/null +++ b/requirements/catalog/history.json @@ -0,0 +1,1821 @@ +{ + "about": "Which releases state each rule. A rule in the catalog lists them in suite.releases, from suite.since on. A rule that only older releases state is under removed, with suite.until, the first version that doesn't state it. See requirements/README.md.", + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "versions": [ + "2026-01-11", + "2026-01-23", + "2026-04-08", + "2026-08-25", + "draft" + ], + "releases": [ + { + "version": "2026-01-11", + "ref": "release/2026-01-11", + "commit": "56bad560fbf7d42cc28a8156152f5da94f2505b9", + "rules": 140, + "matched": { + "same wording": 73, + "same wording, other page": 0, + "same wording, other list stem": 32, + "reworded": 2, + "reworded, other page": 0, + "not stated after this release": 4, + "moved out of the shopping pages": 29 + } + }, + { + "version": "2026-01-23", + "ref": "release/2026-01-23", + "commit": "e783ffa2eaeaac9938642a3ddae0f2439b6aa488", + "rules": 150, + "matched": { + "same wording": 110, + "same wording, other page": 0, + "same wording, other list stem": 0, + "reworded": 1, + "reworded, other page": 0, + "not stated after this release": 9, + "moved out of the shopping pages": 30 + } + }, + { + "version": "2026-04-08", + "ref": "release/2026-04-08", + "commit": "9c9d6fce39ffa8bf7cb66309c378b79fb75b5382", + "rules": 379, + "matched": { + "same wording": 364, + "same wording, other page": 0, + "same wording, other list stem": 0, + "reworded": 0, + "reworded, other page": 0, + "not stated after this release": 9, + "moved out of the shopping pages": 6 + } + }, + { + "version": "2026-08-25", + "ref": "release/2026-08-25", + "commit": "87dd4b1fcff9105d68173120897237fa784c74ef", + "rules": 512, + "matched": { + "same wording": 503, + "same wording, other page": 0, + "same wording, other list stem": 0, + "reworded": 2, + "reworded, other page": 0, + "not stated after this release": 0, + "moved out of the shopping pages": 7 + } + } + ], + "removed": [ + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0011", + "text_digest": "34e52599f3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "Cursors are opaque strings that implementations MAY encode as stateless keyset tokens.", + "normalized": "cursors are opaque strings that implementations may encode as stateless keyset tokens", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 18, + "source": { + "file": "docs/specification/catalog/search.md", + "start_line": 66, + "end_line": 67, + "section": "Catalog Search Capability > Pagination", + "block_type": "paragraph", + "page": "specification/catalog/search/", + "anchor": "pagination" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-PAGINATION-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "implementation guidance", + "since": "2026-04-08", + "until": "2026-08-25", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/search.md", + "start_line": 66, + "level": "MAY", + "text_digest": "34e52599f3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0012", + "text_digest": "e2548c97cc", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "SHOULD", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "Implementations SHOULD accept a page size of at least 10.", + "normalized": "implementations should accept a page size of at least 10", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 20, + "source": { + "file": "docs/specification/catalog/search.md", + "start_line": 71, + "end_line": 75, + "section": "Catalog Search Capability > Pagination > Page Size", + "block_type": "paragraph", + "page": "specification/catalog/search/", + "anchor": "page-size" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-PAGE-SIZE-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "implementation guidance", + "since": "2026-04-08", + "until": "2026-08-25", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/search.md", + "start_line": 71, + "level": "SHOULD", + "text_digest": "e2548c97cc" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0013", + "text_digest": "f908ab09df", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "When the requested limit exceeds the implementation's maximum, implementations MAY clamp to their maximum silently — returning fewer results without error.", + "normalized": "when the requested limit exceeds the implementation's maximum, implementations may clamp to their maximum silently - returning fewer results without error", + "condition": "When the requested limit exceeds the implementation's maximum", + "referenced_fields": [], + "compound_parent": null, + "document_order": 21, + "source": { + "file": "docs/specification/catalog/search.md", + "start_line": 71, + "end_line": 75, + "section": "Catalog Search Capability > Pagination > Page Size", + "block_type": "paragraph", + "page": "specification/catalog/search/", + "anchor": "page-size" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-PAGE-SIZE-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "implementation guidance", + "since": "2026-04-08", + "until": "2026-08-25", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/search.md", + "start_line": 71, + "level": "MAY", + "text_digest": "f908ab09df" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0014", + "text_digest": "095d4127a1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Clients MUST NOT assume the response size equals the requested limit.", + "normalized": "clients must not assume the response size equals the requested limit", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 22, + "source": { + "file": "docs/specification/catalog/search.md", + "start_line": 71, + "end_line": 75, + "section": "Catalog Search Capability > Pagination > Page Size", + "block_type": "paragraph", + "page": "specification/catalog/search/", + "anchor": "page-size" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-PAGE-SIZE-03", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "no actor detected", + "since": "2026-04-08", + "until": "2026-08-25", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/search.md", + "start_line": 71, + "level": "MUST NOT", + "text_digest": "095d4127a1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0253", + "text_digest": "97c37dbeb6", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**MUST** include at least one message with `severity: escalation` when returning `status` = `requires_escalation`.", + "normalized": "must include at least one message with severity: escalation when returning status = requires_escalation", + "condition": "when returning `status` = `requires_escalation`", + "referenced_fields": [ + "requires_escalation", + "severity", + "status" + ], + "compound_parent": null, + "document_order": 79, + "source": { + "file": "docs/specification/checkout.md", + "start_line": 269, + "end_line": 270, + "section": "Checkout Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/checkout/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-BUSINESS-05", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "until": "2026-04-08", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 263, + "level": "MUST", + "text_digest": "97c37dbeb6" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 269, + "level": "MUST", + "text_digest": "97c37dbeb6" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0254", + "text_digest": "c90c72488b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Verification failure **MUST** only affect the `messages` array.", + "normalized": "verification failure must only affect the messages array", + "condition": null, + "referenced_fields": [ + "messages" + ], + "compound_parent": null, + "document_order": 100, + "source": { + "file": "docs/specification/checkout.md", + "start_line": 293, + "end_line": 299, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-08", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "no actor detected", + "since": "2026-04-08", + "until": "2026-08-25", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 293, + "level": "MUST", + "text_digest": "c90c72488b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0255", + "text_digest": "9be5fa6ad5", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Messages **SHOULD** use the `path` field to identify which specific claim(s) could not be verified.", + "normalized": "messages should use the path field to identify which specific claim(s) could not be verified", + "condition": null, + "referenced_fields": [ + "path" + ], + "compound_parent": null, + "document_order": 102, + "source": { + "file": "docs/specification/checkout.md", + "start_line": 293, + "end_line": 299, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-10", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "no actor detected", + "since": "2026-04-08", + "until": "2026-08-25", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 293, + "level": "SHOULD", + "text_digest": "9be5fa6ad5" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0256", + "text_digest": "787575634f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MAY** then provide valid proof and resubmit, restructure the checkout (e.g., remove ineligible items, update claims), or abandon the attempt.", + "normalized": "the platform may then provide valid proof and resubmit, restructure the checkout (e.g., remove ineligible items, update claims), or abandon the attempt", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 103, + "source": { + "file": "docs/specification/checkout.md", + "start_line": 293, + "end_line": 299, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-11", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "until": "2026-08-25", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 293, + "level": "MAY", + "text_digest": "787575634f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0257", + "text_digest": "df29ac59fe", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses SHOULD use these values when authoritative data (e.g. address) is absent", + "normalized": "businesses should use these values when authoritative data (e.g. address) is absent", + "condition": "when authoritative data (e.g. address) is absent", + "referenced_fields": [], + "compound_parent": null, + "document_order": 130, + "source": { + "file": "docs/specification/checkout.md", + "start_line": 368, + "end_line": 371, + "section": "Checkout Capability > Entities > Context", + "block_type": "paragraph", + "page": "specification/checkout/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-CONTEXT-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-23", + "until": "2026-04-08", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 368, + "level": "SHOULD", + "text_digest": "df29ac59fe" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0258", + "text_digest": "e3dad067b0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses MAY ignore unsupported values without returning errors.", + "normalized": "businesses may ignore unsupported values without returning errors", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 130, + "source": { + "file": "docs/specification/checkout.md", + "start_line": 368, + "end_line": 371, + "section": "Checkout Capability > Entities > Context", + "block_type": "paragraph", + "page": "specification/checkout/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-CONTEXT-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-23", + "until": "2026-04-08", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 368, + "level": "MAY", + "text_digest": "e3dad067b0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0259", + "text_digest": "ae029d1342", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When a host receives a checkout response with a `continue_url` from a business that advertises ECP support, it **MAY** initiate an ECP session by loading the URL in an embedded context.", + "normalized": "when a host receives a checkout response with a continue_url from a business that advertises ecp support, it may initiate an ecp session by loading the url in an embedded context", + "condition": "When a host receives a checkout response with a `continue_url` from a business that advertises ECP support", + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 48, + "source": { + "file": "docs/specification/embedded-checkout.md", + "start_line": 118, + "end_line": 120, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "block_type": "paragraph", + "page": "specification/embedded-checkout/", + "anchor": "loading-an-embedded-checkout-url" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-LOADING-AN-EMBEDDED-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "until": "2026-01-23", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 118, + "level": "MAY", + "text_digest": "ae029d1342" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0260", + "text_digest": "ab577222b9", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **MUST** create at least one of the following globals:", + "normalized": "the host must create at least one of the following globals", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 175, + "source": { + "file": "docs/specification/embedded-checkout.md", + "start_line": 419, + "end_line": 422, + "section": "Checkout Capability - EP Binding > Transport & Messaging > Communication Channels > Communication Channel for Native Hosts", + "block_type": "paragraph", + "page": "specification/embedded-checkout/", + "anchor": "communication-channel-for-native-hosts" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-COMMUNICATION-CHANNEL-07", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "until": "2026-04-08", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 341, + "level": "MUST", + "text_digest": "ab577222b9" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 419, + "level": "MUST", + "text_digest": "ab577222b9" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0261", + "text_digest": "e265cfa568", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.5, + "clause": "To ensure security, both parties **MUST** implement appropriate", + "normalized": "to ensure security, both parties must implement appropriate", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 338, + "source": { + "file": "docs/specification/embedded-checkout.md", + "start_line": 1177, + "end_line": 1177, + "section": "Checkout Capability - EP Binding > Security & Error Handling > Security for Web-Based Hosts > Content Security Policy (CSP)", + "block_type": "paragraph", + "page": "specification/embedded-checkout/", + "anchor": "content-security-policy-csp" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-CONTENT-SECURITY-POLICY-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "until": "2026-01-23", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1177, + "level": "MUST", + "text_digest": "e265cfa568" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0262", + "text_digest": "d1b39a8397", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The message responder **SHOULD** use error codes mapped to **[W3C DOMException](https://webidl.spec.whatwg.org/#idl-DOMException)** names where possible.", + "normalized": "the message responder should use error codes mapped to w3c domexception names where possible", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 383, + "source": { + "file": "docs/specification/embedded-checkout.md", + "start_line": 1236, + "end_line": 1240, + "section": "Checkout Capability - EP Binding > Security & Error Handling > Error Codes", + "block_type": "paragraph", + "page": "specification/embedded-checkout/", + "anchor": "error-codes" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-ERROR-CODES-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "until": "2026-04-08", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1160, + "level": "SHOULD", + "text_digest": "d1b39a8397" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1236, + "level": "SHOULD", + "text_digest": "d1b39a8397" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0263", + "text_digest": "be3be2c530", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "MCP clients **MUST** include the UCP platform profile URI with every request.", + "normalized": "mcp clients must include the ucp platform profile uri with every request", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 3, + "source": { + "file": "docs/specification/checkout-mcp.md", + "start_line": 64, + "end_line": 66, + "section": "Checkout Capability - MCP Binding > Protocol Fundamentals > Platform Profile Advertisement", + "block_type": "paragraph", + "page": "specification/checkout-mcp/", + "anchor": "platform-profile-advertisement" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-PLATFORM-PROFILE-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-01-11", + "until": "2026-01-23", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout-mcp.md", + "start_line": 64, + "level": "MUST", + "text_digest": "be3be2c530" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0264", + "text_digest": "50d66b978b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "The `_meta.ucp.profile` field **MUST** be present in every MCP tool invocation to enable version compatibility checking and capability negotiation.", + "normalized": "the _meta.ucp.profile field must be present in every mcp tool invocation to enable version compatibility checking and capability negotiation", + "condition": null, + "referenced_fields": [ + "_meta.ucp.profile" + ], + "compound_parent": null, + "document_order": 5, + "source": { + "file": "docs/specification/checkout-mcp.md", + "start_line": 84, + "end_line": 85, + "section": "Checkout Capability - MCP Binding > Protocol Fundamentals > Platform Profile Advertisement", + "block_type": "paragraph", + "page": "specification/checkout-mcp/", + "anchor": "platform-profile-advertisement" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-PLATFORM-PROFILE-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-01-11", + "until": "2026-01-23", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout-mcp.md", + "start_line": 84, + "level": "MUST", + "text_digest": "50d66b978b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0056", + "text_digest": "adb26a1879", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **SHOULD** render options in the provided order", + "normalized": "platforms should render options in the provided order", + "condition": null, + "referenced_fields": [], + "compound_parent": "**For ordering:**", + "document_order": 67, + "source": { + "file": "docs/specification/fulfillment.md", + "start_line": 198, + "end_line": 198, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-11", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "until": "2026-08-25", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 200, + "level": "SHOULD", + "text_digest": "08886e0103", + "clause": "Platforms **SHOULD** render options in the provided order" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 198, + "level": "SHOULD", + "text_digest": "adb26a1879" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 198, + "level": "SHOULD", + "text_digest": "adb26a1879" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0057", + "text_digest": "7ea8962c4d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "EXTENSION", + "actor_confidence": 0.9, + "clause": "Extensions that extend fulfillment with new method types (e.g., `local_delivery`) **MUST** add an extension schema that:", + "normalized": "extensions that extend fulfillment with new method types (e.g., local_delivery) must add an extension schema that", + "condition": null, + "referenced_fields": [ + "local_delivery" + ], + "compound_parent": null, + "document_order": 103, + "source": { + "file": "docs/specification/fulfillment.md", + "start_line": 337, + "end_line": 338, + "section": "Fulfillment Extension > Configuration > Adding New Methods", + "block_type": "paragraph", + "page": "specification/fulfillment/", + "anchor": "adding-new-methods" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-ADDING-NEW-METHODS-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "attributed to the extension", + "since": "2026-01-11", + "until": "2026-08-25", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 339, + "level": "MUST", + "text_digest": "7ea8962c4d" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 337, + "level": "MUST", + "text_digest": "7ea8962c4d" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 337, + "level": "MUST", + "text_digest": "7ea8962c4d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0041", + "text_digest": "92ea191b2b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** respond quickly with a 2xx HTTP status code to acknowledge receipt", + "normalized": "must respond quickly with a 2xx http status code to acknowledge receipt", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Platform:**", + "document_order": 87, + "source": { + "file": "docs/specification/order.md", + "start_line": 329, + "end_line": 329, + "section": "Order Capability > Guidelines", + "block_type": "list_item", + "page": "specification/order/", + "anchor": "guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-GUIDELINES-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "no actor detected", + "since": "2026-01-11", + "until": "2026-04-08", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/order.md", + "start_line": 339, + "level": "MUST", + "text_digest": "de55178249", + "clause": "**MUST** respond quickly with a 2xx HTTP status code to acknowledge receipt" + }, + { + "version": "2026-01-23", + "file": "docs/specification/order.md", + "start_line": 329, + "level": "MUST", + "text_digest": "92ea191b2b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0042", + "text_digest": "0531f624a3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** sign all webhook payloads using a key from their `signing_keys` array (published in `/.well-known/ucp`).", + "normalized": "must sign all webhook payloads using a key from their signing_keys array (published in /.well-known/ucp)", + "condition": null, + "referenced_fields": [ + "signing_keys" + ], + "compound_parent": "**Business:**", + "document_order": 90, + "source": { + "file": "docs/specification/order.md", + "start_line": 334, + "end_line": 336, + "section": "Order Capability > Guidelines", + "block_type": "list_item", + "page": "specification/order/", + "anchor": "guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-GUIDELINES-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "no actor detected", + "since": "2026-01-11", + "until": "2026-04-08", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/order.md", + "start_line": 344, + "level": "MUST", + "text_digest": "618f425437", + "clause": "**MUST** sign all webhook payloads using a key from their `signing_keys` array (published in `/.well-known/ucp`)." + }, + { + "version": "2026-01-23", + "file": "docs/specification/order.md", + "start_line": 334, + "level": "MUST", + "text_digest": "0531f624a3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0043", + "text_digest": "f4c2f03458", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The signature **MUST** be included in the `Request-Signature` header as a detached JWT (RFC 7797).", + "normalized": "the signature must be included in the request-signature header as a detached jwt (rfc 7797)", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Business:**", + "document_order": 91, + "source": { + "file": "docs/specification/order.md", + "start_line": 334, + "end_line": 336, + "section": "Order Capability > Guidelines", + "block_type": "list_item", + "page": "specification/order/", + "anchor": "guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-GUIDELINES-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "no actor detected", + "since": "2026-01-11", + "until": "2026-04-08", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/order.md", + "start_line": 344, + "level": "MUST", + "text_digest": "e0936ede0f", + "clause": "The signature **MUST** be included in the `Request-Signature` header as a detached JWT (RFC 7797)." + }, + { + "version": "2026-01-23", + "file": "docs/specification/order.md", + "start_line": 334, + "level": "MUST", + "text_digest": "f4c2f03458" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0044", + "text_digest": "e27fc7ad69", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** include business identifier in webhook path or headers", + "normalized": "must include business identifier in webhook path or headers", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Business:**", + "document_order": 95, + "source": { + "file": "docs/specification/order.md", + "start_line": 340, + "end_line": 340, + "section": "Order Capability > Guidelines", + "block_type": "list_item", + "page": "specification/order/", + "anchor": "guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-GUIDELINES-07", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "no actor detected", + "since": "2026-01-11", + "until": "2026-04-08", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/order.md", + "start_line": 350, + "level": "MUST", + "text_digest": "f1fc3a26a6", + "clause": "**MUST** include business identifier in webhook path or headers" + }, + { + "version": "2026-01-23", + "file": "docs/specification/order.md", + "start_line": 340, + "level": "MUST", + "text_digest": "e27fc7ad69" + } + ] + } + } + ], + "moved_out": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout-rest.md", + "start_line": 1288, + "clause": "All requests **MUST** include the `UCP-Agent` header containing the platform profile URI using Dictionary Structured Field syntax ([RFC 8941](https://datatracker.ietf.org/doc/html/rfc8941){target=\"_blank\"}).", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/checkout-rest.md", + "start_line": 1292, + "clause": "Operations that modify state **SHOULD** support idempotency.", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/checkout-rest.md", + "start_line": 1292, + "clause": "When provided, the server **MUST**:", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 281, + "clause": "All ECP messages **MUST** use JSON-RPC 2.0 format ([RFC 7159](https://datatracker.ietf.org/doc/html/rfc7159)).", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 281, + "clause": "Each message **MUST** contain:", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 285, + "clause": "**MUST** be `\"2.0\"`", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 295, + "clause": "**MUST** include a unique `id` field", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 296, + "clause": "Receiver **MUST** respond with matching `id`", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 297, + "clause": "Response **MUST** be either a `result` or `error` object", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 303, + "clause": "**MUST NOT** include an `id` field", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 304, + "clause": "Receiver **MUST NOT** send a response", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 309, + "clause": "For requests (messages with `id`), receivers **MUST** respond with either:", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 327, + "clause": "The host **MUST** listen for `postMessage` calls from the embedded window", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 327, + "clause": "when a message is received, they **MUST** validate the origin matches the `checkout_url` used to start the checkout.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 333, + "clause": "Upon validation, the host **MAY** create a `MessageChannel`, and transfer one of its ports in the result of the [`ec.ready` response](#ecready).", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 333, + "clause": "When a host responds with a `MessagePort`, all subsequent messages **MUST** be sent over that channel.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 333, + "clause": "Otherwise, the host and business **MUST** continue using `postMessage()` between their `window` objects, including origin validation.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 341, + "clause": "When the host is a native application, they MUST inject globals into the Embedded Checkout that allows `postMessage` communication between the web and native environments.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 349, + "clause": "This object **MUST** implement the following interface:", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 357, + "clause": "The host **MUST** parse the JSON string before processing.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 360, + "clause": "For messages traveling from the host to the Embedded Checkout, the host **MUST** inject JavaScript in the webview that will call `window.EmbeddedCheckoutProtocol.postMessage()` with the JSON RPC message.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 360, + "clause": "The Embedded Checkout **MUST** initialize this global object — and start listening for `postMessage()` calls — before the `ec.ready` message is sent.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1183, + "clause": "**Business:** **MUST** set `frame-ancestors ;` to ensure it's only embedded by trusted hosts.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1193, + "clause": "**Intermediate Iframe:** The host **MAY** use an intermediate iframe (e.g., on a host-controlled subdomain) to embed the business's page.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1199, + "clause": "The intermediate iframe **MUST** implement a strict `frame-src` policy, dynamically set to allow *only* the specific `` for the current embedded session (e.g., `frame-src ;`).", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1207, + "clause": "All business iframes **MUST** be sandboxed to restrict their capabilities.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1207, + "clause": "The following sandbox attributes **SHOULD** be applied, but a host", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1207, + "clause": "business **MAY** negotiate additional capabilities", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1217, + "clause": "Hosts **SHOULD** use the `credentialless` attribute on the iframe to load it in a new, ephemeral context.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout-rest.md", + "start_line": 1202, + "clause": "All requests **MUST** include the `UCP-Agent` header containing the platform profile URI using Dictionary Structured Field syntax ([RFC 8941](https://datatracker.ietf.org/doc/html/rfc8941){target=\"_blank\"}).", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout-rest.md", + "start_line": 1206, + "clause": "Operations that modify state **SHOULD** support idempotency.", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout-rest.md", + "start_line": 1206, + "clause": "When provided, the server **MUST**:", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 360, + "clause": "All ECP messages **MUST** use JSON-RPC 2.0 format ([RFC 7159](https://datatracker.ietf.org/doc/html/rfc7159)).", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 360, + "clause": "Each message **MUST** contain:", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 363, + "clause": "**MUST** be `\"2.0\"`", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 373, + "clause": "**MUST** include a unique `id` field", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 374, + "clause": "Receiver **MUST** respond with matching `id`", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 375, + "clause": "Response **MUST** be either a `result` or `error` object", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 381, + "clause": "**MUST NOT** include an `id` field", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 382, + "clause": "Receiver **MUST NOT** send a response", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 387, + "clause": "For requests (messages with `id`), receivers **MUST** respond with either:", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 405, + "clause": "The host **MUST** listen for `postMessage` calls from the embedded window", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 405, + "clause": "when a message is received, they **MUST** validate the origin matches the `checkout_url` used to start the checkout.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 411, + "clause": "Upon validation, the host **MAY** create a `MessageChannel`, and transfer one of its ports in the result of the [`ec.ready` response](#ecready).", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 411, + "clause": "When a host responds with a `MessagePort`, all subsequent messages **MUST** be sent over that channel.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 411, + "clause": "Otherwise, the host and business **MUST** continue using `postMessage()` between their `window` objects, including origin validation.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 419, + "clause": "When the host is a native application, they MUST inject globals into the Embedded Checkout that allows `postMessage` communication between the web and native environments.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 427, + "clause": "This object **MUST** implement the following interface:", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 435, + "clause": "The host **MUST** parse the JSON string before processing.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 438, + "clause": "For messages traveling from the host to the Embedded Checkout, the host **MUST** inject JavaScript in the webview that will call `window.EmbeddedCheckoutProtocol.postMessage()` with the JSON RPC message.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 438, + "clause": "The Embedded Checkout **MUST** initialize this global object — and start listening for `postMessage()` calls — before the `ec.ready` message is sent.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1254, + "clause": "To ensure security, both parties **MUST** implement appropriate **[Content Security Policy (CSP)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP)** directives:", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1258, + "clause": "**Business:** **MUST** set `frame-ancestors ;` to ensure it's only embedded by trusted hosts.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1268, + "clause": "**Intermediate Iframe:** The host **MAY** use an intermediate iframe (e.g., on a host-controlled subdomain) to embed the business's page.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1274, + "clause": "The intermediate iframe **MUST** implement a strict `frame-src` policy, dynamically set to allow *only* the specific `` for the current embedded session (e.g., `frame-src ;`).", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1282, + "clause": "All business iframes **MUST** be sandboxed to restrict their capabilities.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1282, + "clause": "The following sandbox attributes **SHOULD** be applied, but a host", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1282, + "clause": "business **MAY** negotiate additional capabilities", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1292, + "clause": "Hosts **SHOULD** use the `credentialless` attribute on the iframe to load it in a new, ephemeral context.", + "now_on": [ + "docs/specification/embedded-protocol.md" + ] + }, + { + "version": "2026-04-08", + "file": "docs/specification/cart-rest.md", + "start_line": 468, + "clause": "All requests **MUST** include the `UCP-Agent` header containing the platform profile URI using Dictionary Structured Field syntax ([RFC 8941](https://datatracker.ietf.org/doc/html/rfc8941){target=\"_blank\"}).", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-04-08", + "file": "docs/specification/cart-rest.md", + "start_line": 472, + "clause": "Operations that modify state **SHOULD** support idempotency.", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-04-08", + "file": "docs/specification/cart-rest.md", + "start_line": 472, + "clause": "When provided, the server **MUST**:", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-rest.md", + "start_line": 1237, + "clause": "All requests **MUST** include the `UCP-Agent` header containing the platform profile URI using Dictionary Structured Field syntax ([RFC 8941](https://datatracker.ietf.org/doc/html/rfc8941){target=\"_blank\"}).", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-rest.md", + "start_line": 1241, + "clause": "Operations that modify state **SHOULD** support idempotency.", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-rest.md", + "start_line": 1241, + "clause": "When provided, the server **MUST**:", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/rest.md", + "start_line": 478, + "clause": "All requests **MUST** include the `UCP-Agent` header containing the platform profile URI using Dictionary Structured Field syntax ([RFC 8941](https://datatracker.ietf.org/doc/html/rfc8941){target=\"_blank\"}).", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/rest.md", + "start_line": 482, + "clause": "Operations that modify state **SHOULD** support idempotency.", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/rest.md", + "start_line": 482, + "clause": "When provided, the server **MUST**:", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/rest.md", + "start_line": 608, + "clause": "All requests **MUST** include the `UCP-Agent` header containing the platform profile URI using Dictionary Structured Field syntax ([RFC 8941](https://datatracker.ietf.org/doc/html/rfc8941){target=\"_blank\"}).", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1304, + "clause": "All requests **MUST** include the `UCP-Agent` header containing the platform profile URI using Dictionary Structured Field syntax ([RFC 8941](https://datatracker.ietf.org/doc/html/rfc8941){target=\"_blank\"}).", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1308, + "clause": "Operations that modify state **SHOULD** support idempotency.", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1308, + "clause": "When provided, the server **MUST**:", + "now_on": [ + "docs/specification/lodging/booking/rest.md" + ] + } + ] +} diff --git a/requirements/catalog/requirements.lock.json b/requirements/catalog/requirements.lock.json new file mode 100644 index 0000000..96b33a7 --- /dev/null +++ b/requirements/catalog/requirements.lock.json @@ -0,0 +1,5868 @@ +{ + "about": "Stable IDs for the shopping requirements catalog: one entry for every ID ever issued. An ID never changes, and a retired ID's number is never issued again. See requirements/README.md.", + "lock_version": 1, + "entries": [ + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0001", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "e83d2886ae", + "context": null, + "text": "platforms may submit captured consent on complete_checkout alongside payment", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0002", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "c9f256df93", + "context": null, + "text": "on create_cart, update_cart, create_checkout, and update_checkout, businesses should surface missing dependencies as warning messages so the platform can collect the data on a subsequent operation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0003", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "847433efb5", + "context": null, + "text": "on complete_checkout, businesses must not transition the checkout to completed while a confirmed consent decision has unmet data dependencies", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0004", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "ad6ce21b41", + "context": null, + "text": "missing dependencies must be surfaced via the standard error handling flow", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0005", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "0a45016c80", + "context": null, + "text": "use the advertised settings. businesses must advertise the complete set of consent options they support", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0006", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "226370a92e", + "context": null, + "text": "platforms decide which choices to present to the buyer and when; when presenting a choice, platforms must use the advertised description, links, granted value, and purpose/segment grouping", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0007", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "13c85fda79", + "context": null, + "text": "identifiers outside the dev.ucp.consent.* namespace are opaque handles; platforms must not infer semantics from such paths alone", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0008", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "0251ef1234", + "context": null, + "text": "when submitting consent, platforms must include every advertised purpose and segment key, carrying both granted and source for each", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0009", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "4bdc908f46", + "context": null, + "text": "omitting an advertised key within a submitted consent map must not be used to signal any value", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0010", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "7affd65168", + "context": null, + "text": "advertised set is authoritative. businesses must ignore purposes and segments in a request that were not advertised in a prior response", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0011", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "7918cf85e6", + "context": null, + "text": "platforms must not prompt for or transmit purposes or segments the business did not advertise", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0012", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "9ea5b9f143", + "context": null, + "text": "source attribution requires a buyer-stated preference. platforms must set source: \"platform\" only when the granted value reflects the buyer's stated preference", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0013", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "d0e9b52bdd", + "context": null, + "text": "for choices to which no buyer preference applies, platforms must echo the advertised source unchanged", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0014", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "72244fd689", + "context": null, + "text": "per-business attribution. a consent decision captured with a specific business is attributable only to that business; platforms must not propagate it as the basis for source: \"platform\" in a different business's request", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0015", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "6b49f63890", + "context": null, + "text": "persistence and reversibility. platforms may persist a buyer's prior preferences (source: \"platform\") across interactions with the same business", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0016", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "40c2df7171", + "context": null, + "text": "persistence and reversibility. platforms may suppress re-presentation of unchanged values", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0017", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "047c97c48a", + "context": null, + "text": "where preferences are persisted, platforms should give the buyer the ability to change them", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0001", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "94c63ccb74", + "context": null, + "text": "because the cart checkout extension composes onto the base checkout schema, line_items remains a required request field; the platform must include line_items", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0002", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "f2b0ac0e44", + "context": null, + "text": "because the cart checkout extension composes onto the base checkout schema, line_items remains a required request field; the platform should set it to an empty array (\"line_items\": []). array (\"line_items\": [])", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0003", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "cbf1d2e8f8", + "context": null, + "text": "the business must use the cart contents", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0004", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "224effb21d", + "context": null, + "text": "the business must ignore overlapping fields in the checkout payload", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0005", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "806cb9a689", + "context": null, + "text": "if an incomplete checkout already exists for the given cart_id, the business must return the existing checkout session rather than creating a new one", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0006", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "7bceaecc6b", + "context": null, + "text": "when checkout is initialized via cart_id, the cart and checkout sessions should be linked for the duration of the checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0007", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "c0e93a9c7b", + "context": null, + "text": "during active checkout - business should maintain the cart and reflect relevant checkout modifications (quantity changes, item removals) back to the cart", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0008", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "eb1bb7f6a1", + "context": null, + "text": "after checkout completion - business may clear the cart based on ttl, completion of the checkout, or other business logic", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0009", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "270ff2319a", + "context": null, + "text": "the platform may include item.quantity_unit to assert the sale-basis identity", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0010", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "b06903616a", + "context": null, + "text": "the business must not treat an outstanding action as a reason to reject an unrelated cart operation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0011", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "8aadc86b6f", + "context": null, + "text": "the platform may continue to add, remove, and update items while an action is outstanding", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0012", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "43243fdbc1", + "context": null, + "text": "after processing an action, the platform should use get cart or a subsequent update response to obtain the latest cart", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0013", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "ee96ea27c0", + "context": null, + "text": "may use carts for pre-purchase exploration and session persistence", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0014", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "e9a222cc67", + "context": null, + "text": "should convert cart to checkout when user expresses purchase intent", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0015", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "a44182f239", + "context": null, + "text": "may display continue_url for handoff to business ui", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0016", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "fd4476d57f", + "context": null, + "text": "should handle not_found gracefully when cart expires or is canceled", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0017", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "a865390d42", + "context": null, + "text": "should provide continue_url for cart handoff and session recovery", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0018", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "58b0c041a9", + "context": null, + "text": "should provide estimated totals when calculable", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0019", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "917c61cb95", + "context": null, + "text": "may omit fulfillment totals until checkout when address is unknown", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0020", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "02d0f50b5c", + "context": null, + "text": "should return informational messages for validation warnings", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0021", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "f7f262706c", + "context": null, + "text": "may set cart expiry via expires_at", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0022", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "ffbb6a7174", + "context": null, + "text": "should follow cart lifecycle requirements when checkout is initialized via cart_id", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0023", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "1376be1e26", + "context": null, + "text": "when all requested items are unavailable, the business may return an error response instead of creating a cart resource", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0024", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "911557d18f", + "context": null, + "text": "the platform must send the entire cart resource", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0025", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "6e0bf927e2", + "context": null, + "text": "business must return the cart state before deletion", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0026", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "0fbda2ac13", + "context": null, + "text": "subsequent operations for this cart id should return not_found", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0027", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "d17ebc6153", + "context": null, + "text": "signal values must not be buyer-asserted claims", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0028", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "e0b70c9533", + "context": null, + "text": "taxes may be included where calculable", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0029", + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "c4f79c54ee", + "context": null, + "text": "platforms should assume cart totals are estimates; accurate taxes are computed at checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0030", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "6d177cbebb", + "context": null, + "text": "businesses must include an embedded service binding with config.delegate in cart responses to indicate ecap availability and allowed delegations for a specific session", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0031", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "3bfce93152", + "context": null, + "text": "when a host receives a cart response with a continue_url from a business that advertises ecap support, it may initiate an ecap session by loading the url in an embedded context", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0032", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "40901b2bee", + "context": null, + "text": "before loading the embedded context, the host should", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0033", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "1eb6a4ff57", + "context": null, + "text": "to initiate the session, the host must augment the continue_url with supported ecap query parameters", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0034", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "99fb03a018", + "context": null, + "text": "parameters should use either ep or ep_cart prefixes to avoid namespace pollution and clearly distinguish ecap parameters from business-specific query parameters", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0035", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "3ef6139abf", + "context": "all ecap parameters are passed via url query string, not http headers, to ensure maximum compatibility across different embedding environments. parameters should use either ep or ep_cart prefixes to avoid namespace pollution and clearly distinguish ecap parameters from business-specific query parameters", + "text": "may be empty if no delegations are needed", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0036", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "dde250e17d", + "context": "all ecap parameters are passed via url query string, not http headers, to ensure maximum compatibility across different embedding environments. parameters should use either ep or ep_cart prefixes to avoid namespace pollution and clearly distinguish ecap parameters from business-specific query parameters", + "text": "should be a subset of config.delegate from the embedded service binding", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0037", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "9854f1f8d0", + "context": null, + "text": "the ucp.version in all responses must echo the ep_version negotiated during session initialization and confirmed by the host in the ep.cart.ready response", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0038", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "22d5406f7a", + "context": null, + "text": "the version is session-bound - it must not change for the duration of the ecap session", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0039", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "236108e3a6", + "context": null, + "text": "core messages are defined by the ecap specification and must be supported by all implementations", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0040", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "12e38410dc", + "context": null, + "text": "upon rendering, the embedded cart must broadcast readiness to the parent context using the ep.cart.ready message", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0041", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "d081ee92cc", + "context": "payload", + "text": "must be a subset of both ep_cart_delegate (what host requested) and config.delegate from the cart response (what business allows)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0042", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "9f75f5e48f", + "context": null, + "text": "the ep.cart.ready message is a request, which means that the host must respond to complete the handshake", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0043", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "2732dd948e", + "context": "result payload", + "text": "the version confirms the negotiated ep_version and status must be \"success\"", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0044", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "5e3413cd0d", + "context": "result payload", + "text": "when present, host must not include credential - the channel will be re-established and any credential sent here will be discarded", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0045", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "abdc68d4ce", + "context": "result payload", + "text": "the requested authorization data, can be in the form of an oauth token, jwt, api keys, etc. must be set if auth is present in the request", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0046", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "8c8a34c733", + "context": "result payload", + "text": "must not be set if upgrade is present", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0047", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "93c5cfff95", + "context": null, + "text": "hosts may respond with an upgrade field to update the communication channel between host and embedded cart", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0048", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "eb3704265c", + "context": null, + "text": "currently, this object only supports a port field, which must be a messageport object", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0049", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "ad6f991ef5", + "context": null, + "text": "currently, this object only supports a port field, which must be transferred to the embedded cart context (e.g., with {transfer: [port2]} on the host's iframe.contentwindow.postmessage() call)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0050", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "8c0d70a15b", + "context": null, + "text": "when the host responds with an upgrade object, the embedded cart must discard any other information in the message, send a new ep.cart.ready message over the upgraded communication channel, and wait for a new response", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0051", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "a809664137", + "context": null, + "text": "all subsequent messages must be sent only over the upgraded communication channel", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0052", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "b4ddfaed6e", + "context": null, + "text": "if the host cannot complete the handshake (e.g., origin validation failure or protocol state violation), it must respond with an error_response result", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0053", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "dfcef5c6f2", + "context": null, + "text": "the host must tear down the embedded context", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0054", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "c45fb9f3f1", + "context": null, + "text": "the host may redirect the buyer to continue_url if present", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0055", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "55ae656dbf", + "context": null, + "text": "the embedded cart must not send further messages after receiving a handshake error", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0056", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "2f6da07657", + "context": null, + "text": "when error escalation is required, embedded cart must issue an ep.cart.error notification per the session error pattern", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0057", + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "431af45a47", + "context": null, + "text": "if dev.ucp.shopping.checkout is part of the negotiated capabilities during service discovery, host may proceed to initiate a checkout session based on the completed cart by issuing a create checkout operation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0058", + "file": "docs/specification/shopping/cart/mcp.md", + "text_digest": "7d9d798bfd", + "context": null, + "text": "mcp clients must include a meta object in every request containing protocol metadata", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0059", + "file": "docs/specification/shopping/cart/mcp.md", + "text_digest": "160daf898a", + "context": null, + "text": "platforms may include additional metadata fields", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0060", + "file": "docs/specification/shopping/cart/mcp.md", + "text_digest": "27773aeefb", + "context": "mcp tools separate resource identification from payload data", + "text": "the cart object in the request payload must not contain an id field", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0061", + "file": "docs/specification/shopping/cart/mcp.md", + "text_digest": "748fc7ead3", + "context": null, + "text": "a conforming mcp transport implementation must", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0062", + "file": "docs/specification/shopping/cart/rest.md", + "text_digest": "017f445b50", + "context": null, + "text": "all request and response bodies must be valid json as specified in rfc 8259", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0063", + "file": "docs/specification/shopping/cart/rest.md", + "text_digest": "86f31bc40b", + "context": null, + "text": "all rest endpoints must be served over https with minimum tls version 1.3", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0064", + "file": "docs/specification/shopping/cart/rest.md", + "text_digest": "9655f6d29f", + "context": null, + "text": "when authentication is required, the rest transport may use", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CART-0065", + "file": "docs/specification/shopping/cart/rest.md", + "text_digest": "b40d58d234", + "context": null, + "text": "businesses may require authentication for some operations while leaving others open (e.g., public cart without authentication)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0001", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "40b521f2a3", + "context": null, + "text": "responses can be session-specific and should not be reused across sessions without re-validation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0002", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "1db3a3f0bd", + "context": null, + "text": "the business may provide quantity_unit, unit_price, both, or neither on a variant", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0003", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "ee324c49fb", + "context": null, + "text": "to keep the display comparator defined, the business must use a positive integer for both unit_price.measure.value and unit_price.reference.value", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0004", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "fb6e4f7181", + "context": null, + "text": "the business must set unit_price.currency equal to price.currency", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0005", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "5593fc2913", + "context": null, + "text": "within unit_price, the business must use identical values for measure.unit and reference.unit", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0006", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "20cb8c2a29", + "context": null, + "text": "the business may use different scale values for those measures", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0007", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "41a9ebc50c", + "context": null, + "text": "the business must not perform cross-unit or currency conversion as part of the unit-price calculation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0008", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "e6da3fa860", + "context": null, + "text": "the business must compute the comparator from price.amount and those scaled values", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0009", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "685546d140", + "context": null, + "text": "the business must round the result once to the currency's minor units according to its pricing rules and return it as unit_price.amount", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0010", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "979cf19ab7", + "context": null, + "text": "the platform must not recompute it or substitute its own result", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0011", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "b566d9087f", + "context": null, + "text": "on transaction lines, presence marks the role: the business must echo unit_price on any line whose pricing basis differs from its sale basis (see checkout - pricing basis)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0012", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "96e978ebd7", + "context": null, + "text": "platforms may geo-detect context from request headers", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0013", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "35b444ee45", + "context": null, + "text": "businesses should use these values when verified inputs (e.g., shipping address) are absent", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0014", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "e137bb0b98", + "context": null, + "text": "businesses may ignore or down-rank them if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0015", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "d647a85835", + "context": null, + "text": "eligibility and policy enforcement must occur at checkout time using binding transaction data", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0016", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "d33d7257de", + "context": null, + "text": "price filter values are denominated in context.currency; when the presentment currency differs, businesses should convert before applying (see price filter)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0017", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "f49fb6dcf9", + "context": null, + "text": "when context.eligibility claims are present, businesses that accept them may adjust price / list_price directly for strikethrough display", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0018", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "7e656cdd76", + "context": null, + "text": "when context.eligibility claims are present, businesses that accept them may use messages with code: \"eligibility_benefit\" to attribute the adjustment to a specific claim", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0019", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "d17ebc6153", + "context": null, + "text": "signal values must not be buyer-asserted claims", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0020", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "31e5f5455d", + "context": null, + "text": "businesses should return the most relevant variant and media item first - default for lookups, best match based on query and context for search", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0021", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "def47e598c", + "context": null, + "text": "platforms should treat the first media item they present as featured", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0022", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "f0f49c3eac", + "context": null, + "text": "businesses should return the featured variant media item as the first element", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0023", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "def47e598c", + "context": null, + "text": "platforms should treat the first media item they present as featured", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0024", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "47d4d69eb8", + "context": null, + "text": "a platform must not reject a product or response because it does not recognize a media item's type", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0025", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "50fd9f9ad5", + "context": null, + "text": "it may present such an item from preview and name, or omit it", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0026", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "e03f1b1b3e", + "context": null, + "text": "a platform may refuse to load or embed a media url that does not use the https scheme", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0027", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "2272b4257d", + "context": null, + "text": "a business that provides sources should include the rendition at url", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0028", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "f04858a60f", + "context": null, + "text": "the business should make url the most broadly decodable rendition, because a platform that does not select from sources loads url directly", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0029", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "6610f50a78", + "context": null, + "text": "a platform that embeds the player must isolate it from the platform's authority: no platform credentials, no access to platform apis or agent tools, no protocol messaging privileges, and no navigation of the host application", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0030", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "972c1b040c", + "context": null, + "text": "before embedding, it must decline the item unless url is an absolute https url without userinfo that is not same-site with the platform", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0031", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "b272585568", + "context": null, + "text": "the business may use the same action id in separate responses; that equality does not identify the same work", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0032", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "9525c6155e", + "context": null, + "text": "a concrete action-type contract may define stronger correlation for its instances", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0033", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "1532082837", + "context": null, + "text": "catalog defines no action lifecycle, polling, or resume behavior; a concrete action-type contract may define those behaviors for processing its instances", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0034", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "950a55324b", + "context": null, + "text": "get_product returns severity: \"unrecoverable\" when an identifier doesn't resolve; agents must not retry the same id (see the rest and mcp examples)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0035", + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "440c8529d2", + "context": null, + "text": "the response may include informational messages indicating which identifiers were not found", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0036", + "file": "docs/specification/shopping/catalog/mcp.md", + "text_digest": "7d9d798bfd", + "context": null, + "text": "mcp clients must include a meta object in every request containing protocol metadata", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0037", + "file": "docs/specification/shopping/catalog/mcp.md", + "text_digest": "440c8529d2", + "context": null, + "text": "the response may include informational messages indicating which identifiers were not found", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0038", + "file": "docs/specification/shopping/catalog/mcp.md", + "text_digest": "440c8529d2", + "context": null, + "text": "the response may include informational messages indicating which identifiers were not found", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0039", + "file": "docs/specification/shopping/catalog/mcp.md", + "text_digest": "748fc7ead3", + "context": null, + "text": "a conforming mcp transport implementation must", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0040", + "file": "docs/specification/shopping/catalog/mcp.md", + "text_digest": "6e5b8536e3", + "context": "a conforming mcp transport implementation must", + "text": "when the lookup capability is advertised, both lookup_catalog and get_product tools must be available", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0041", + "file": "docs/specification/shopping/catalog/mcp.md", + "text_digest": "f9a2cc0384", + "context": "a conforming mcp transport implementation must", + "text": "return successful result for lookup requests; unknown identifiers result in fewer products returned (may include informational not_found messages)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0042", + "file": "docs/specification/shopping/catalog/rest.md", + "text_digest": "440c8529d2", + "context": null, + "text": "the response may include informational messages indicating which identifiers were not found", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0043", + "file": "docs/specification/shopping/catalog/rest.md", + "text_digest": "440c8529d2", + "context": null, + "text": "the response may include informational messages indicating which identifiers were not found", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0044", + "file": "docs/specification/shopping/catalog/rest.md", + "text_digest": "350f72606a", + "context": null, + "text": "a conforming rest transport implementation must", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0045", + "file": "docs/specification/shopping/catalog/rest.md", + "text_digest": "35a3e3f4dd", + "context": "a conforming rest transport implementation must", + "text": "when the lookup capability is advertised, both /catalog/lookup and /catalog/product must be available", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-0046", + "file": "docs/specification/shopping/catalog/rest.md", + "text_digest": "f52390f942", + "context": "a conforming rest transport implementation must", + "text": "return http 200 for lookup requests; unknown identifiers result in fewer products returned (may include informational not_found messages)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0001", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "05e08eb33c", + "context": "input | lookup_catalog", + "text": "may support sku, handle, url, etc", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0002", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "4d7409c0dd", + "context": null, + "text": "implementations must support lookup by product id and variant id", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0003", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "bb0139a517", + "context": null, + "text": "implementations may additionally support secondary identifiers such as sku or handle, provided these are also fields on the returned product object", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0004", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "fddacf45d0", + "context": null, + "text": "duplicate identifiers in the request must be deduplicated", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0005", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "1976ef2539", + "context": null, + "text": "when an identifier matches multiple products (e.g., a sku shared across variants), implementations return matching products and may limit the result set", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0006", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "25191003c1", + "context": null, + "text": "when multiple identifiers resolve to the same product, it must be returned once", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0007", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "67d7d28db3", + "context": null, + "text": "variants without an inputs entry must not appear in lookup responses", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0008", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "0bedb69a17", + "context": null, + "text": "implementations should accept at least 10 identifiers per request", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0009", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "1531d8ed95", + "context": null, + "text": "implementations may enforce a maximum batch size", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0010", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "160c793a93", + "context": null, + "text": "implementations must reject requests exceeding their limit with an appropriate error (http 400 request_too_large for rest, json-rpc -32602 for mcp)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0011", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "2d2516174f", + "context": "the response returns the product with complete context (title, description, media, options) and a subset of variants matching product.selected", + "text": "variants should contain the featured variant and other variants matching product.selected", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0012", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "00e5f417b1", + "context": "the response returns the product with complete context (title, description, media, options) and a subset of variants matching product.selected", + "text": "the requested variant must be the first element (featured)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0013", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "50e0b6763f", + "context": null, + "text": "each option name must appear at most once", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0014", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "f39f08283c", + "context": null, + "text": "the response must include product.selected when the product has configurable options - reflecting the effective selections after any relaxation when the request includes selected, or the featured variant's default selections otherwise", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0015", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "cc0f65f541", + "context": null, + "text": "when the product has no configurable options, selected may be empty or omitted", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0016", + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "515545af2a", + "context": null, + "text": "option values in the response should include availability signals relative to product.selected", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0001", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "40c24b8fcb", + "context": null, + "text": "a valid search request must include at least one of: a query string, one or more filters, or an extension-defined input", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0002", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "00372ac58e", + "context": null, + "text": "extensions may define additional inputs (e.g., visual similarity, product references)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0003", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "eb6fa97298", + "context": null, + "text": "implementations must validate that incoming requests contain at least one recognized input", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0004", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "b25650806a", + "context": null, + "text": "implementations should reject empty or invalid requests with an appropriate error", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0005", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "a4f12b4af8", + "context": null, + "text": "standard filters are defined below; merchants may support additional custom filters via additionalproperties", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0006", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "723735e908", + "context": null, + "text": "a business may encode them as stateless keyset tokens", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0007", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "df9ab2c9da", + "context": null, + "text": "when limit is omitted, the business must apply a default page size", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0008", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "92b975f598", + "context": null, + "text": "a default of 10 is recommended, but the business may choose another value", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0009", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "048b735954", + "context": null, + "text": "the business may return fewer results than the requested or default page size, including when enforcing its maximum page size", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0010", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "5eb21c8c87", + "context": null, + "text": "a platform must not assume that the response count equals either value", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0011", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "34e52599f3", + "context": null, + "text": "cursors are opaque strings that implementations may encode as stateless keyset tokens", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0012", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "e2548c97cc", + "context": null, + "text": "implementations should accept a page size of at least 10", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0013", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "f908ab09df", + "context": null, + "text": "when the requested limit exceeds the implementation's maximum, implementations may clamp to their maximum silently - returning fewer results without error", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0014", + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "095d4127a1", + "context": null, + "text": "clients must not assume the response size equals the requested limit", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0001", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "cd05227e99", + "context": null, + "text": "discovering the sale basis. the sale basis is item data: the platform should discover an item's quantity_unit - including scale and any increment - from the catalog before transacting", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0002", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "fb0415a3cb", + "context": null, + "text": "the platform may include quantity_unit on a request line to assert the basis it believes it is ordering in", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0003", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "62ebd6174e", + "context": null, + "text": "when the platform includes it, the business must compare the asserted and authoritative machine identities", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0004", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "6ef3b4aed5", + "context": "if an asserted quantity_unit does not match the item's authoritative sale basis, the requested quantity is denominated in a basis the business does not sell in. silent conversion is forbidden in both directions: neither party may reinterpret a quantity the other denominated without surfacing the change. the business resolves the mismatch in one of two ways", + "text": "convert, visibly. when the business can convert the asserted basis to its authoritative basis (for example, pounds to kilograms), it may apply the request as a visible line revision: the line carries the authoritative descriptor and the converted quantity - rounded once to the authoritative scale according to its rules, with any ordering-increment policy applied after conversion - and the response includes a warning messages[] entry at the line", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0005", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "95f6f6314f", + "context": "if an asserted quantity_unit does not match the item's authoritative sale basis, the requested quantity is denominated in a basis the business does not sell in. silent conversion is forbidden in both directions: neither party may reinterpret a quantity the other denominated without surfacing the change. the business resolves the mismatch in one of two ways", + "text": "reject, recoverably. when it cannot or chooses not to convert (for example, a quantity of fasteners denominated in litres), the business must reject the request's effect on that line with a recoverable business outcome naming the authoritative basis", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0006", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "9f67312357", + "context": "if an asserted quantity_unit does not match the item's authoritative sale basis, the requested quantity is denominated in a basis the business does not sell in. silent conversion is forbidden in both directions: neither party may reinterpret a quantity the other denominated without surfacing the change. the business resolves the mismatch in one of two ways", + "text": "on create, the line is not created and the message identifies the item in content; when no line can be created, the business may return an error response instead", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0007", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "369ccf093d", + "context": null, + "text": "ordering increment. the sale basis may declare an increment - the ordering granularity, in steps, the business sells in", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0008", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "be19f9b8ba", + "context": null, + "text": "platform-authored quantities should be integer multiples of the line's effective increment", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0009", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "471fb3330b", + "context": null, + "text": "the increment is merchandising policy, not a representational bound, and schema validation does not enforce it: on receiving an off-increment quantity, the business may accept it, revise the line to an increment multiple, or reject it with a recoverable business outcome", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0010", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "dec45589b9", + "context": null, + "text": "a revision must be returned as a revised line quantity with an explanatory messages[] entry", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0011", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "4c7e4ba353", + "context": null, + "text": "the business must not silently reinterpret the requested quantity", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0012", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "dd9079f287", + "context": null, + "text": "the business may also revise a quantity for its own reasons (for example, limited stock)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0013", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "8becb2a472", + "context": null, + "text": "such revisions should stay on the increment grid so subsequent platform stepper edits from the revised value remain on-grid", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0014", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "f8e51f41e6", + "context": null, + "text": "echoing the sale basis. the business may omit quantity_unit from a response line whose effective sale-basis identity is the default identity", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0015", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "3bb377c529", + "context": null, + "text": "the business must include quantity_unit on the item in every cart, checkout, and order line response whenever the effective identity differs from the default identity", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0016", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "a3b9edd660", + "context": null, + "text": "the business must compute the line total as price × quantity × 10^-scale and round once at the line", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0017", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "3ebe3248f4", + "context": null, + "text": "the platform must not recompute a line total from the fractional quantity and substitute its own rounding", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0018", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "da38167665", + "context": null, + "text": "pricing basis. item.price is always denominated against the sale basis, but the business may quote it from a different measurement basis - for example, apples priced per pound and sold per each", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0019", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "bd31c0f360", + "context": null, + "text": "on authoritative responses the business must include item.unit_price on every cart, checkout, and order line whose pricing basis differs from its sale basis: the rate that determines the charge travels with the line, exactly as the sale basis itself does", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0020", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "bbea25f035", + "context": null, + "text": "when the pricing basis is the sale basis, unit_price remains a catalog display comparator and may be omitted from lines", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0021", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "af51ddc764", + "context": null, + "text": "the response must not contain order", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0022", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "d424fedfda", + "context": null, + "text": "after processing the action according to its action type's contract, the platform should use get checkout or, outside complete_in_progress, a subsequent update checkout response to obtain the latest checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0023", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "1c657a54ec", + "context": null, + "text": "if an action prevents complete checkout from being accepted, the business must return the current checkout with status: incomplete and an error message with severity: \"recoverable\" whose path selects that exact action occurrence", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0024", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "525a30062e", + "context": "get checkout | contract", + "text": "the platform may invoke get checkout; the business's response is authoritative", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0025", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "3bd78d0877", + "context": "get checkout | contract", + "text": "the platform may repeat get checkout with bounded backoff set by the action contract or platform policy", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0026", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "e94f7b7609", + "context": "get checkout | contract", + "text": "the platform must stop repeated requests at expires_at", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0027", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "ccf0b15003", + "context": "update checkout | contract", + "text": "the platform must not start a new update checkout operation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0028", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "58f10a1130", + "context": "update checkout | contract", + "text": "if the business receives a new update checkout request, it must leave the checkout unchanged and return the current checkout with a recoverable error message", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0029", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "7e560a0d63", + "context": "complete checkout | contract", + "text": "the platform must not start a new complete checkout operation during complete_in_progress", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0030", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "4441824ed1", + "context": "cancel checkout | contract", + "text": "the platform must follow the fallback, handoff, and cancellation race rules below before attempting cancel checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0031", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "b392324c48", + "context": null, + "text": "when it contains no action, the platform should use get checkout to observe business processing", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0032", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "12329820ba", + "context": null, + "text": "because update checkout is unavailable after complete checkout is accepted, the business must surface any action that requires input through update checkout before accepting complete checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0033", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "e92495e10d", + "context": null, + "text": "the platform must use get checkout to confirm that the business reflected the result, for example by removing the action or changing the checkout status", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0034", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "e937ec9401", + "context": null, + "text": "if the same action key and id remain, the platform must not process it again unless its contract explicitly permits retry and every safe-retry condition holds", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0035", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "0f80aad830", + "context": null, + "text": "if the platform cannot complete an action, or the business does not update the checkout within a timeout set by the action contract or platform policy before expires_at, the platform should follow any applicable action fallback", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0036", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "afaf5a02f1", + "context": null, + "text": "if no fallback can continue the checkout and continue_url is available, the platform should use it to hand off the checkout to the buyer", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0037", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "f4423ba09c", + "context": null, + "text": "the platform must not attempt cancel checkout while either fallback or handoff can still continue the checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0038", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "de9b426014", + "context": null, + "text": "if neither fallback nor handoff can continue, the platform should use get checkout to retrieve the latest state and attempt cancel checkout only if it still reports complete_in_progress", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0039", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "37585e2cc9", + "context": null, + "text": "cancellation can race completion; the platform must not treat the checkout as canceled unless the business reports status: canceled", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0040", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "68730700a3", + "context": null, + "text": "when no resource exists to act on, messages should use severity: \"unrecoverable\"", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0041", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "a66058228d", + "context": null, + "text": "businesses should surface such messages as early as possible", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0042", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "1a84344de6", + "context": null, + "text": "platforms should prioritize resolving recoverable errors before initiating handoff", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0043", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "34664bbf7f", + "context": null, + "text": "businesses should mark standard errors with severity: recoverable to signal that platforms should provide appropriate ux (out-of-stock messaging, address validation prompts, payment method changes) rather than generic error messages or deferring to checkout completion", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0044", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "f88ead9106", + "context": null, + "text": "path must be an rfc 9535 jsonpath expression relative to the root of the ucp response object", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0045", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "a3efff7283", + "context": null, + "text": "when multiple errors apply to the same field, each message should carry the most specific path applicable", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0046", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "8da7db45a5", + "context": null, + "text": "businesses may act on recognized claims during the session (adjusting pricing, granting product access, applying provisional discounts)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0047", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "90b3974648", + "context": null, + "text": "all accepted claims must be resolved before the transaction can complete", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0048", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "ab6a714be7", + "context": null, + "text": "unrecognized or inapplicable claims must not block the checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0049", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "80e3a8d49f", + "context": null, + "text": "businesses should notify the buyer via messages with type: \"warning\" when a claim is not accepted", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0050", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "39c0060e67", + "context": null, + "text": "businesses may use type: \"info\" to explain the effects of accepted claims", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0051", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "7ace1fe265", + "context": null, + "text": "at completion, accepted claims that remain unverified must result in type: \"error\" with code: \"eligibility_invalid\" (see below)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0052", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "4e67dc5855", + "context": null, + "text": "businesses must not complete a transaction with unresolved eligibility claims", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0053", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "79e6b4f5b0", + "context": null, + "text": "the business must return an error in messages with code: \"eligibility_invalid\" and severity: \"recoverable\"", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0054", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "11372efe76", + "context": null, + "text": "when an action prevents the requested effect, the business must set that error message's path to select the exact action occurrence as specified in actions", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0055", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "bb1452383a", + "context": null, + "text": "otherwise, the business should use path to identify which specific claim(s) could not be verified", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0056", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "daf94805c3", + "context": null, + "text": "any action or discount state contributed by a negotiated extension may remain current according to that extension", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0057", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "57ed2f5e33", + "context": null, + "text": "the platform may then retry that extension's verification flow, use update checkout for ordinary checkout changes (e.g., remove ineligible items) or to rescind the claim, or abandon the attempt", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0058", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "c00cb541a5", + "context": null, + "text": "with the claim resolved, the checkout may advance to ready_for_complete", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0059", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "c9eeb1baa3", + "context": null, + "text": "the platform may provide valid proof and retry the verification flow, or rescind the claim", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0060", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "acfcf54c52", + "context": null, + "text": "the presentation field on warning messages controls the rendering contract the platform must follow", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0061", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "f1104000fd", + "context": "display content | notice (default)", + "text": "must", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0062", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "2c5d9d6629", + "context": "display content | disclosure", + "text": "must", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0063", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "16da19e571", + "context": "proximity to path | notice (default)", + "text": "may", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0064", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "3214a8b4f3", + "context": "proximity to path | disclosure", + "text": "must", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0065", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "f2580192f4", + "context": "dismissible | notice (default)", + "text": "may", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0066", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "454e178f36", + "context": "dismissible | disclosure", + "text": "must not", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0067", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "164a7d0bf1", + "context": "render image_url | notice (default)", + "text": "may", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0068", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "22696563a2", + "context": "render image_url | disclosure", + "text": "must", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0069", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "1d6897ff8a", + "context": "render url | notice (default)", + "text": "may", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0070", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "93029fc74c", + "context": "render url | disclosure", + "text": "should", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0071", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "d8320eb452", + "context": "escalate if cannot honor | disclosure", + "text": "must via continue_url", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0072", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "63eb9ce1e6", + "context": null, + "text": "platforms must display the warning content to the buyer", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0073", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "332fc3eb7b", + "context": null, + "text": "platforms may render notices in a banner, tray, or toast", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0074", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "bfb5252497", + "context": null, + "text": "platforms may allow the buyer to dismiss them", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0075", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "6f25efb860", + "context": null, + "text": "warnings with presentation: \"disclosure\" carry notices - safety warnings, allergen declarations, compliance content, etc. - that must follow the prescribed rendering contract below", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0076", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "06cceec768", + "context": "platform requirements", + "text": "must display the warning content to the buyer", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0077", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "ae0c97bc1a", + "context": "platform requirements", + "text": "must display the warning in proximity to the component referenced by path, preserving the association between the disclosure and its subject", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0078", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "a1863922cf", + "context": "platform requirements", + "text": "must not hide, collapse, or auto-dismiss the warning", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0079", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "fd7771f63a", + "context": "platform requirements", + "text": "must render image_url when present (e.g., warning symbol, energy class label)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0080", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "820a2f9efe", + "context": "platform requirements", + "text": "should render url as a navigable reference link when present", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0081", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "0263f18adb", + "context": null, + "text": "warnings with presentation: \"disclosure\" should be given rendering priority over notices", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0082", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "489e05ddc3", + "context": null, + "text": "platforms that cannot honor the disclosure rendering contract must escalate to merchant ui via continue_url rather than silently downgrading to a notice", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0083", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "beafa21ced", + "context": "business requirements", + "text": "must set presentation: \"disclosure\" when the warning content must be displayed alongside a specific component and must not be hidden or auto-dismissed", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0084", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "0d63274715", + "context": "business requirements", + "text": "should use the path field to associate disclosures with the relevant component in the response", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0085", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "53c2decc92", + "context": "business requirements", + "text": "should provide a code that identifies the disclosure category (e.g., prop65, allergens, energy_label)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0086", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "2c7e59d4d5", + "context": "business requirements", + "text": "when the disclosure renders a structured policies[] entry, the code must equal that policy's type to link the two (see policies)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0087", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "05d6c52b57", + "context": "business requirements", + "text": "should provide image_url when the disclosure has an associated visual element (e.g., warning symbol, energy class label)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0088", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "1017c13bf3", + "context": "business requirements", + "text": "should provide url when a reference link is available for the buyer to learn more", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0089", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "a0fa76b0d2", + "context": null, + "text": "when affirmative buyer acknowledgment or authorization is also required, the business may combine the disclosure with the escalation mechanisms described in the checkout status lifecycle to ensure the appropriate buyer input is obtained", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0090", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "db543e2f62", + "context": null, + "text": "businesses should use buyer-provided data (context and other inputs) and product attributes to resolve jurisdiction-specific requirements", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0091", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "e583c00f08", + "context": null, + "text": "businesses must provide continue_url when returning status = requires_escalation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0092", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "a625c88b45", + "context": null, + "text": "for all other non-terminal statuses (incomplete, ready_for_complete, complete_in_progress), businesses should provide continue_url", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0093", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "ec3bac66a2", + "context": null, + "text": "for terminal states (completed, canceled), continue_url should be omitted", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0094", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "e6f81fd0dd", + "context": null, + "text": "the continue_url must be an absolute https url", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0095", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "a1b795b70e", + "context": null, + "text": "the continue_url should preserve checkout state for seamless handoff", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0096", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "5c90286075", + "context": null, + "text": "businesses may implement state preservation using either approach", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0097", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "1717dcf0e4", + "context": null, + "text": "businesses should implement support for this format to facilitate checkout handoff and accelerated entry-for example, a platform can prefill checkout state when initiating a buy-now flow", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0098", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "404be9b6a9", + "context": null, + "text": "may engage an agent to facilitate the checkout session (e.g. add items to the checkout session, select fulfillment address)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0099", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "5bfe027f42", + "context": null, + "text": "may send the user from the trusted, deterministic ui back to the agent at any time", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0100", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "6bb1d43d30", + "context": null, + "text": "may provide agent context when the platform indicates that the request was done by an agent", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0101", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "d0db3bab09", + "context": null, + "text": "must use continue_url when checkout status is requires_escalation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0102", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "50c0cd861a", + "context": null, + "text": "may use continue_url to hand off to business ui in other situations", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0103", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "195cd330b6", + "context": null, + "text": "when performing handoff, should prefer business-provided continue_url over platform-constructed checkout permalinks", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0104", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "30d3516026", + "context": null, + "text": "must send a confirmation email after the checkout has been completed", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0105", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "ab9070f00a", + "context": null, + "text": "should provide accurate error messages", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0106", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "adbf81349f", + "context": null, + "text": "logic handling the checkout sessions must be deterministic", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0107", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "59ce9514a8", + "context": null, + "text": "must provide continue_url when returning status = requires_escalation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0108", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "43a4121d2d", + "context": null, + "text": "must include at least one message with severity of requires_buyer_input or requires_buyer_review when returning status = requires_escalation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0109", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "456e8a756f", + "context": null, + "text": "should provide continue_url in all non-terminal checkout responses", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0110", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "04933d86f1", + "context": null, + "text": "to minimize discrepancies and a streamlined user experience, product data (price/title etc.) provided by the business through the feeds should match the actual attributes returned in the response", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0111", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "bac6d12327", + "context": null, + "text": "the platform is required to send the entire checkout resource containing any data updates to write-only data fields", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0112", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "2d86535f99", + "context": null, + "text": "the platform must not use complete checkout to poll or resume accepted processing", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0113", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "9727e007fa", + "context": null, + "text": "if the platform does not receive a response to complete checkout, it should use get checkout with bounded backoff to obtain the current state", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0114", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "1c7ec12253", + "context": null, + "text": "if the platform does not receive a response to complete checkout, it must stop at expires_at", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0115", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "5ba0cdb896", + "context": null, + "text": "only if get checkout still does not establish whether the business processed the original request, the platform may submit the identical original complete checkout request again with the same idempotency key", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0116", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "47be3f62c8", + "context": null, + "text": "the platform must not use a new idempotency key for that retry", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0117", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "0c5c2c4998", + "context": null, + "text": "a genuinely new complete checkout operation after the checkout returns to ready_for_complete must use a fresh idempotency key, even if the payload is unchanged", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0118", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "56dd9d5db0", + "context": null, + "text": "at the time of order persistence, fields from checkout may be used to construct the order representation (i.e. information like line_items, fulfillment will be used to create the initial order representation)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0119", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "6f0756c2eb", + "context": null, + "text": "if the checkout session cannot be canceled (e.g. checkout session is already canceled or completed), then businesses should send back an error indicating the operation is not allowed", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0120", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "1929627a42", + "context": null, + "text": "any checkout session with a status that is not equal to completed or canceled should be cancelable", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0121", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "35b444ee45", + "context": null, + "text": "businesses should use these values when verified inputs (e.g., shipping address) are absent", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0122", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "e137bb0b98", + "context": null, + "text": "businesses may ignore or down-rank them if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0123", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "d647a85835", + "context": null, + "text": "eligibility and policy enforcement must occur at checkout time using binding transaction data", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0124", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "916a488164", + "context": null, + "text": "unlike context (buyer-asserted preferences) and buyer (self-reported identity), signal values must not be buyer-asserted claims - platforms provide signals based on direct observation or by relaying independently verifiable third-party attestations", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0125", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "711f3836a0", + "context": null, + "text": "businesses should provide all relevant links for the transaction", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0126", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "9616b961a3", + "context": null, + "text": "businesses may define custom types for domain-specific needs", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0127", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "85bc46fdb7", + "context": null, + "text": "platforms should handle unknown types gracefully by displaying them using the title field or omitting them", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0128", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "633738379e", + "context": null, + "text": "platforms must render all top-level entries in the order provided", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0129", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "9686f34d66", + "context": null, + "text": "platforms may render sub-lines as supplementary detail", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0130", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "ed6e5e1a5e", + "context": null, + "text": "platforms must not interpret, filter, reorder, aggregate, or apply display logic of their own", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0131", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "78eb4e97bf", + "context": "invariants of totals[]", + "text": "platforms should use display_text when provided", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0132", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "debd639454", + "context": "invariants of totals[]", + "text": "well-known types have default display labels as fallback (see table below); unknown types must include display_text", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0133", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "d725369b04", + "context": "invariants of totals[]", + "text": "exactly one type: \"subtotal\" must be present", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0134", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "749321cc43", + "context": "invariants of totals[]", + "text": "exactly one type: \"total\" must be present", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0135", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "bcc53c3234", + "context": null, + "text": "platforms must not substitute their own computed totals for the business's values", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0136", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "8771b7a275", + "context": null, + "text": "platforms may verify the provided totals", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0137", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "287b81954f", + "context": null, + "text": "if the computed sum does not match the type: \"total\" entry, the platform must not alter the rendered output - the business's presented totals are authoritative for display", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0138", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "594b999c87", + "context": null, + "text": "however, platforms must not autonomously complete a checkout with mismatched totals", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0139", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "b43edb9f37", + "context": null, + "text": "platforms should reject the checkout or escalate and ask for buyer review via continue_url", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0140", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "67b450f295", + "context": null, + "text": "when display_text is provided, platforms must use it", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0141", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "6e36252844", + "context": null, + "text": "when omitted on a well-known type, platforms should use the default label above", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0142", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "df0becb156", + "context": null, + "text": "the sign convention for well-known types is schema-enforced: subtractive types (discount, items_discount) must have negative amounts", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0143", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "cf4dce95bc", + "context": null, + "text": "additive types (subtotal, fulfillment, tax, fee) must have non-negative amounts", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0144", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "26a6f1432c", + "context": null, + "text": "the type field is an open string - businesses may use values beyond the well-known set", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0145", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "3ff1a76ae8", + "context": null, + "text": "unknown types must include display_text (schema-enforced) and the sign on the amount is self-describing", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0146", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "2440b50ae1", + "context": null, + "text": "all types except subtotal and total may appear multiple times - for example, multi-jurisdiction tax lines or itemized fees", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0147", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "c933a8a798", + "context": null, + "text": "each top-level entry may include a lines array", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0148", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "c49ea1cbba", + "context": null, + "text": "invariant: sum(lines[].amount) must equal the parent entry's amount", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0149", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "880a06d004", + "context": null, + "text": "the business controls what must be rendered (top-level entries) versus what may be optionally surfaced (sub-lines)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0150", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "57a1e5693e", + "context": null, + "text": "platforms should render sub-lines when provided", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0151", + "file": "docs/specification/shopping/checkout/a2a.md", + "text_digest": "3fd4c0c210", + "context": null, + "text": "the checkout object must be returned as part of a datapart object with key a2a.ucp.checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0152", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "d3a16bd983", + "context": null, + "text": "businesses must include an embedded service binding with config.delegate in checkout responses to indicate ecp availability and allowed delegations for a specific session", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0153", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "b9d5e402e6", + "context": null, + "text": "when a host receives a checkout response with an embedded service binding, it may initiate an ecp session by loading the continue_url in an embedded context", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0154", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "40901b2bee", + "context": null, + "text": "before loading the embedded context, the host should", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0155", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "3230757599", + "context": null, + "text": "to initiate the session, the host must augment the continue_url with ecp query parameters using the ec_ prefix", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0156", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "db1f71589a", + "context": "all ecp parameters are passed via url query string, not http headers, to ensure maximum compatibility across different embedding environments. parameters use the ec_ prefix to avoid namespace pollution and clearly distinguish ecp parameters from business-specific query parameters", + "text": "the version is negotiated at session initialization and must remain constant for the lifetime of the ecp session - neither party may change the version after the handshake", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0157", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "036cb43223", + "context": "all ecp parameters are passed via url query string, not http headers, to ensure maximum compatibility across different embedding environments. parameters use the ec_ prefix to avoid namespace pollution and clearly distinguish ecp parameters from business-specific query parameters", + "text": "should be a subset of config.delegate from the embedded service binding", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0158", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "81afb6fb27", + "context": "token format", + "text": "businesses must document their expected token format and validation process", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0159", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "e5b5268361", + "context": null, + "text": "businesses must validate authentication according to their security requirements", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0160", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "33e3f0b0e5", + "context": null, + "text": "when ec_color_scheme is not provided, the embedded checkout can use the buyer's system preference via the prefers-color-scheme media query or the sec-ch-prefers-color-scheme http client hint, and should listen for changes and update accordingly", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0161", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "cbd466887a", + "context": "implementation notes", + "text": "by default, the embedded checkout should respect the buyer's system color scheme preference and listen for changes to update accordingly", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0162", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "830bc43945", + "context": "implementation notes", + "text": "when ec_color_scheme is explicitly provided, it must override the system preference, be applied immediately upon load, and be enforced for the duration of the session", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0163", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "1e3b81573d", + "context": "implementation notes", + "text": "businesses may ignore unsupported values", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0164", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "cf58d72baa", + "context": "each stage is a subset of the previous", + "text": "the host should only request delegations present in config.delegate", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0165", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "2c534b146e", + "context": "each stage is a subset of the previous", + "text": "the business should not accept delegations not present in config.delegate", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0166", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "bf3f2784f2", + "context": "each stage is a subset of the previous", + "text": "the business must confirm accepted delegations in ec.ready", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0167", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "7c0f80c2dd", + "context": null, + "text": "however, the embedded checkout may restrict delegation to authenticated or approved hosts based on business policy", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0168", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "a7063be24b", + "context": null, + "text": "the embedded checkout must indicate accepted delegations in the ec.ready request via the delegate field (see ec.ready)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0169", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "71b19fcb62", + "context": null, + "text": "if a requested delegation is not accepted, the embedded checkout must handle that action using its own ui", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0170", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "b24866bb8b", + "context": "embedded checkout responsibilities", + "text": "must fire the appropriate {action}_request message when that action is triggered", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0171", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "b33f69b0a1", + "context": "embedded checkout responsibilities", + "text": "must wait for the host's response before proceeding", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0172", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "12912430f0", + "context": "embedded checkout responsibilities", + "text": "must not show its own ui for that delegated action", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0173", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "623e486ff4", + "context": "host responsibilities", + "text": "must respond to every {action}_request message it receives", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0174", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "ef9672232b", + "context": "host responsibilities", + "text": "must respond with an appropriate error if the user cancels", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0175", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "d709c5a4ac", + "context": "host responsibilities", + "text": "should show loading/processing states while handling delegation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0176", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "9af2ffa86a", + "context": null, + "text": "when checkout is rendered in embedded mode, the implementation should prevent off-checkout navigation to maintain a focused checkout experience", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0177", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "064ee17546", + "context": "navigation requirements", + "text": "the embedded checkout should block or intercept navigation attempts to urls outside the checkout flow", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0178", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "eea24f25f2", + "context": "navigation requirements", + "text": "the embedded checkout should remove or disable ui elements that would navigate away from checkout (e.g., external links, navigation bars)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0179", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "258443814e", + "context": "navigation requirements", + "text": "the embedder may implement additional navigation restrictions at the container level", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0180", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "35d3489e9b", + "context": null, + "text": "permitted exceptions: the following navigation scenarios may be allowed when required for checkout completion", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0181", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "1df2a4b4f1", + "context": null, + "text": "these exceptions should return the user to the checkout flow upon completion", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0182", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "d27d8e1378", + "context": null, + "text": "the ucp.version in all responses must echo the ec_version negotiated during session initialization and confirmed by the host in the ec.ready response", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0183", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "e31c7d39c1", + "context": null, + "text": "the version is session-bound - it must not change for the duration of the ecp session", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0184", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "629595ef1a", + "context": null, + "text": "core messages are defined by the ecp specification and must be supported by all implementations", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0185", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "49e984cded", + "context": null, + "text": "extensions may extend the embedded protocol by defining additional messages", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0186", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "6610687fbf", + "context": null, + "text": "extension messages must follow the naming convention", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0187", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "a3d2f4d56f", + "context": null, + "text": "upon rendering, the embedded checkout must broadcast readiness to the parent context using the ec.ready message", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0188", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "5983dfa675", + "context": "payload", + "text": "must be a subset of both ec_delegate (what host requested) and config.delegate from the checkout response (what business allows)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0189", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "66c2becef2", + "context": null, + "text": "the ec.ready message is a request, which means that the host must respond to complete the handshake", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0190", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "2e7656caf9", + "context": "result payload", + "text": "the version confirms the negotiated ec_version and status must be \"success\"", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0191", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "d4a5ed6089", + "context": "result payload", + "text": "this version is session-bound - the host explicitly confirms the protocol version here, and it must not change for the duration of the session", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0192", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "5e3413cd0d", + "context": "result payload", + "text": "when present, host must not include credential - the channel will be re-established and any credential sent here will be discarded", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0193", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "abdc68d4ce", + "context": "result payload", + "text": "the requested authorization data, can be in the form of an oauth token, jwt, api keys, etc. must be set if auth is present in the request", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0194", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "8c8a34c733", + "context": "result payload", + "text": "must not be set if upgrade is present", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0195", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "d761ce51d7", + "context": null, + "text": "hosts may respond with an upgrade field to update the communication channel between host and embedded checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0196", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "eb3704265c", + "context": null, + "text": "currently, this object only supports a port field, which must be a messageport object", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0197", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "9dbc2de6b2", + "context": null, + "text": "currently, this object only supports a port field, which must be transferred to the embedded checkout context (e.g., with {transfer: [port2]} on the host's iframe.contentwindow.postmessage() call)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0198", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "7604d830f0", + "context": null, + "text": "when the host responds with an upgrade object, the embedded checkout must discard any other information in the message, send a new ec.ready message over the upgraded communication channel, and wait for a new response", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0199", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "a809664137", + "context": null, + "text": "all subsequent messages must be sent only over the upgraded communication channel", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0200", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "273736b04d", + "context": null, + "text": "the host may also respond with a checkout object, which will be used to populate the checkout ui according to the delegation contract between host and business", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0201", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "b4ddfaed6e", + "context": null, + "text": "if the host cannot complete the handshake (e.g., origin validation failure or protocol state violation), it must respond with an error_response result", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0202", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "dfcef5c6f2", + "context": null, + "text": "the host must tear down the embedded context", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0203", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "c45fb9f3f1", + "context": null, + "text": "the host may redirect the buyer to continue_url if present", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0204", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "0c350741c8", + "context": null, + "text": "the embedded checkout must not send further messages after receiving a handshake error", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0205", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "a49ddfe7c1", + "context": null, + "text": "when error escalation is required, embedded checkout must issue an ec.error notification per the session error pattern", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0206", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "99e001b8a5", + "context": null, + "text": "businesses must send this message whenever checkout.totals changes for any reason", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0207", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "5023f77e0f", + "context": null, + "text": "when a change also triggers a domain-specific message (e.g., ec.line_items.change, ec.buyer.change, or ec.payment.change), the business must send the domain-specific message first, then follow it with ec.totals.change", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0208", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "2f8c3a174a", + "context": null, + "text": "the host must respond with either an error, or the newly-selected payment instruments", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0209", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "f8653b81c3", + "context": null, + "text": "in successful responses, the host must respond with a partial update to the checkout object, with only the payment.instruments field updated", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0210", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "e0c6543fed", + "context": null, + "text": "the embedded checkout must treat this update as a put-style change by entirely replacing the existing state for the provided fields, rather than attempting to merge the new data with existing state", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0211", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "0d386b4856", + "context": null, + "text": "the host must respond with either an error, or the credential for the selected payment instrument", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0212", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "22353ff600", + "context": null, + "text": "in successful responses, the host must supply a partial update to the checkout object, updating the instrument with selected: true with the new credentials field", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0213", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "03e22bb1c3", + "context": null, + "text": "the embedded checkout must treat this update as a put-style change by entirely replacing the existing state for payment.instruments, rather than attempting to merge the new data with existing state", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0214", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "a207de5e37", + "context": "host responsibilities during payment token delegation", + "text": "the host must not silently release a token based solely on the message", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0215", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "3060692cd2", + "context": null, + "text": "the host must respond with either an error, or the newly-selected address", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0216", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "2f14a5d57a", + "context": null, + "text": "in successful responses, the host must respond with an updated fulfillment.methods object, updating the selected_destination_id and destinations fields for fulfillment methods, and otherwise preserving the existing state", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0217", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "fd862f1fd7", + "context": null, + "text": "the embedded checkout must treat this update as a put-style change by entirely replacing the existing state for fulfillment.methods, rather than attempting to merge the new data with existing state", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0218", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "f863ba3cef", + "context": null, + "text": "when a checkout url includes ec_delegate=window.open, the host must handle every ec.window.open_request and acknowledge the request", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0219", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "be256dd9cb", + "context": "embedded checkout responsibilities", + "text": "must send ec.window.open_request when the buyer activates a link presented by the business", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0220", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "f74c8b5260", + "context": "host responsibilities", + "text": "must validate that the requested url uses the https scheme", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0221", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "ac546d4675", + "context": "host responsibilities", + "text": "should apply additional host security policies (e.g., verifying origins)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0222", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "1e520ee6a8", + "context": "host responsibilities", + "text": "must present the content to the buyer for every approved request (e.g., in a modal, new tab, or similar)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0223", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "df7a51899a", + "context": "host responsibilities", + "text": "must respond with a json-rpc success result when the request was processed, or a window_open_rejected_error error if host policy prevented the navigation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0224", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "55e3e568a0", + "context": "host responsibilities", + "text": "may notify the buyer if the request was rejected", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0225", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "cf9241666a", + "context": null, + "text": "the embedded checkout must not present its own ui for the link", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0226", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "1e42c2ea27", + "context": null, + "text": "hosts that need richer context (e.g., link type or label) may cross-reference the requested url against the checkout.links array from the checkout session to obtain additional metadata", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0227", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "95b351b8f1", + "context": "window_open_rejected_error | description", + "text": "the host may notify the buyer that their request was rejected", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0228", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "8f97f24d67", + "context": null, + "text": "the host should display a user confirmation ui before releasing the token", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0229", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "7d9d798bfd", + "context": null, + "text": "mcp clients must include a meta object in every request containing protocol metadata", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0230", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "160daf898a", + "context": null, + "text": "platforms may include additional metadata fields", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0231", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "bd19e02460", + "context": "mcp tools separate resource identification from payload data", + "text": "the checkout object in the request payload must not contain an id field", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0232", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "b640f75fbf", + "context": null, + "text": "the platform must not start a new update_checkout operation while the checkout is complete_in_progress", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0233", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "35bccf4f4a", + "context": null, + "text": "if the business receives a new update_checkout request in that state, it must leave the checkout unchanged and return the current checkout with a recoverable error message", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0234", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "9f730a1543", + "context": null, + "text": "platforms should authenticate agents when using mcp transport", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0235", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "833d001a11", + "context": null, + "text": "response signatures are recommended for", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0236", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "eb1ea646bd", + "context": null, + "text": "response signatures are optional for", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0237", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "748fc7ead3", + "context": null, + "text": "a conforming mcp transport implementation must", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0238", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "89481e6bfe", + "context": null, + "text": "a conforming implementation should", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0239", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "66b14d426c", + "context": null, + "text": "implementers must apply this transformation", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0240", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "dc67c9c070", + "context": null, + "text": "implementers must expose this as an mcp tools/call endpoint", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0241", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "017f445b50", + "context": null, + "text": "all request and response bodies must be valid json as specified in rfc 8259", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0242", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "86f31bc40b", + "context": null, + "text": "all rest endpoints must be served over https with minimum tls version 1.3", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0243", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "4bb048462f", + "context": null, + "text": "the platform must send the entire checkout resource, including any data updates to write-only fields; the supplied resource replaces the existing checkout session state", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0244", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "abb33abf65", + "context": null, + "text": "the platform must not start a new update checkout operation while the checkout is complete_in_progress", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0245", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "171c8ac33e", + "context": null, + "text": "if the business receives a new update checkout request in that state, it must leave the checkout unchanged and return the current checkout with a recoverable error message", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0246", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "036655993f", + "context": null, + "text": "outside complete_in_progress, each update checkout replaces the entire checkout session, so the platform must include all previously set fields it intends to retain", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0247", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "d1ab83442a", + "context": null, + "text": "platforms may choose among authentication mechanisms (api keys, oauth, mtls, http message signatures)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0248", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "2b1505e5e0", + "context": null, + "text": "when http message signatures are used, requests must include valid signature-input and signature headers (and content-digest when a body is present) per rfc 9421", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0249", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "833d001a11", + "context": null, + "text": "response signatures are recommended for", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0250", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "eb1ea646bd", + "context": null, + "text": "response signatures are optional for", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0251", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "9655f6d29f", + "context": null, + "text": "when authentication is required, the rest transport may use", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0252", + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "629a6e09eb", + "context": null, + "text": "businesses may require authentication for some operations while leaving others open (e.g., public checkout without authentication)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0253", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "97c37dbeb6", + "context": null, + "text": "must include at least one message with severity: escalation when returning status = requires_escalation", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0254", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "c90c72488b", + "context": null, + "text": "verification failure must only affect the messages array", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0255", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "9be5fa6ad5", + "context": null, + "text": "messages should use the path field to identify which specific claim(s) could not be verified", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0256", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "787575634f", + "context": null, + "text": "the platform may then provide valid proof and resubmit, restructure the checkout (e.g., remove ineligible items, update claims), or abandon the attempt", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0257", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "df29ac59fe", + "context": null, + "text": "businesses should use these values when authoritative data (e.g. address) is absent", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0258", + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "e3dad067b0", + "context": null, + "text": "businesses may ignore unsupported values without returning errors", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0259", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "ae029d1342", + "context": null, + "text": "when a host receives a checkout response with a continue_url from a business that advertises ecp support, it may initiate an ecp session by loading the url in an embedded context", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0260", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "ab577222b9", + "context": null, + "text": "the host must create at least one of the following globals", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0261", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "e265cfa568", + "context": null, + "text": "to ensure security, both parties must implement appropriate", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0262", + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "d1b39a8397", + "context": null, + "text": "the message responder should use error codes mapped to w3c domexception names where possible", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0263", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "be3be2c530", + "context": null, + "text": "mcp clients must include the ucp platform profile uri with every request", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0264", + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "50d66b978b", + "context": null, + "text": "the _meta.ucp.profile field must be present in every mcp tool invocation to enable version compatibility checking and capability negotiation", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0001", + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "75a607ee1b", + "context": null, + "text": "businesses may advertise discount support for cart only, checkout only, or both", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0002", + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "15ac700129", + "context": null, + "text": "platforms should check which resources are extended before submitting discount codes", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0003", + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "cf1b7d46ea", + "context": null, + "text": "cart-to-checkout continuity: when a cart is converted to a checkout via the cart capability's cart_id field, businesses must carry forward any discount codes that were applied to the cart", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0004", + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "99931074ea", + "context": null, + "text": "codes that are no longer valid at checkout time (e.g., expired, ineligible) should be communicated via messages[] using standard rejection codes", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0005", + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "05ed0d297c", + "context": null, + "text": "implementation guidance: operations that affect order totals, or the user's expectation of the total, should use type: \"warning\" to ensure they are surfaced to the user rather than silently handled by platforms", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0006", + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "9e72b57cbb", + "context": null, + "text": "when the discount extension is active, businesses that choose to accept eligibility claims must surface their effect on pricing as provisional discounts in the applied array", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0007", + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "d72ee70a9e", + "context": null, + "text": "platforms must display provisional discounts to the buyer", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0008", + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "77b348abb6", + "context": null, + "text": "when a business recognizes a claim and it affects pricing, it must surface a corresponding provisional discount in the discounts.applied array", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0009", + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "b7f23c4704", + "context": null, + "text": "at checkout completion, all remaining provisional claims must be resolved (see eligibility verification at completion)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0001", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "cdbd5fec10", + "context": "precedence is scoped to what each field governs", + "text": "when catalog filters.fulfills_to is present, a business must resolve the fulfillment destination and method availability from it rather than from context", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0002", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "fe8277d08b", + "context": "precedence is scoped to what each field governs", + "text": "once a platform sets selected_destination_id on a checkout method, a business must use the referenced destination rather than context.location for that method's fulfillment scope", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0003", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "40ffef1f4a", + "context": null, + "text": "cart-to-checkout conversion initializes the checkout from the cart's context, so the business may use loc_123 to generate an initial checkout fulfillment destination", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0004", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "eb39670f05", + "context": null, + "text": "the two discriminators play different roles by direction: in business responses, every destination carries a required type, so responses are self-describing; in platform requests, the method's contract determines who authors destinations[] and may define a default destination shape when type is omitted", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0005", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "2526f4c07e", + "context": null, + "text": "by default, the platform does not write a method's destinations[]; a contract keyed on the method's type may opt into a platform-writable request shape", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0006", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "3049f1a8c3", + "context": "destination type is required in responses and optional in requests. in responses, every destination carries type, so destinations remain self-describing wherever they appear. in requests, destinations[] is omitted unless a method-specific contract opts into a platform-writable shape", + "text": "that method's defining contract - a future revision of this specification or a negotiated extension - may narrow the response destination shape or opt into a platform-writable request shape", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0007", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "09193f5629", + "context": null, + "text": "a request that includes destinations[] must also include the method's type", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0008", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "b44067a978", + "context": null, + "text": "the platform must not write business location destinations into destinations[]; it selects a location by submitting its stable, opaque, business-scoped id as selected_destination_id", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0009", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "ebf819f726", + "context": null, + "text": "the business must return type: \"business_location\", id, and its buyer-facing name", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0010", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "0656640d46", + "context": null, + "text": "the business may return its postal address in address", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0011", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "62c051ee37", + "context": null, + "text": "a non-null selected_destination_id may carry an id the platform obtained from a catalog response, a location search or lookup, an earlier checkout, or any other source the business recognizes for that method", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0012", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "bdf46e29a3", + "context": "when the business accepts a non-null selected_destination_id, its response", + "text": "must carry that same selected_destination_id value on the method; and", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0013", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "ac1221953c", + "context": "when the business accepts a non-null selected_destination_id, its response", + "text": "must include exactly one destination in that same method's destinations[] whose id equals it, typed as specified in destinations - so the response is self-describing whatever the id's source", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0014", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "cb549868ae", + "context": null, + "text": "the business must revalidate the selected destination's current availability and terms; recognizing an id neither reserves inventory nor guarantees eligibility", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0015", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "3405a629ce", + "context": null, + "text": "the business must not silently substitute another destination: it must not return a different selected_destination_id, and must not keep the submitted id while returning a destination that describes another location", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0016", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "de41b39472", + "context": null, + "text": "when the business cannot accept a selected_destination_id submitted on update checkout - the id is not recognized for that method, or revalidation fails - it follows the general behavior for a rejected update: it must leave the current checkout unchanged", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0017", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "4b4188b3b6", + "context": null, + "text": "when the business cannot accept a selected_destination_id submitted on update checkout - the id is not recognized for that method, or revalidation fails - it follows the general behavior for a rejected update: it must return that checkout with an error message with severity: \"recoverable\" whose path selects the attempted method's selected_destination_id (for example $.fulfillment.methods[0].selected_destination_id)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0018", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "c7748bb9e7", + "context": "for options[].title", + "text": "must distinguish this option from its siblings", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0019", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "7dcad6bd86", + "context": "for options[].title", + "text": "should include method and speed (e.g., \"express shipping\", \"curbside pickup\")", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0020", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "3c15b23155", + "context": "for options[].title", + "text": "must be sufficient for buyer decision if description is absent", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0021", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "57af5875a4", + "context": "for options[].description", + "text": "must not repeat title or total-provides supplementary context only", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0022", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "7e4d50e16f", + "context": "for options[].description", + "text": "should include timing, carrier, or other decision-relevant details", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0023", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "b82083a42f", + "context": "for options[].description", + "text": "should be a complete phrase (e.g., \"arrives dec 12-15 via fedex\")", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0024", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "210c8c5962", + "context": "for options[].description", + "text": "may be omitted if title is self-explanatory", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0025", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "d8d326773b", + "context": "for available_methods[].description", + "text": "must be a standalone sentence explaining what, when, and where", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0026", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "b8449b14d9", + "context": "for available_methods[].description", + "text": "should be usable verbatim in platform dialogue (e.g., \"pants available for pickup at downtown store today at 2pm\")", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0027", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "a953e97c48", + "context": "for ordering", + "text": "businesses should return options[] in a meaningful order (e.g., cheapest first, fastest first)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0028", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "765f49eb7f", + "context": "for ordering", + "text": "platforms should preserve that order", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0029", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "b4c3462586", + "context": "for ordering", + "text": "platforms may re-order it (e.g. to match known buyer preferences or surface-specific ranking)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0030", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "676047abce", + "context": "for ordering", + "text": "they must preserve the method/option grouping", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0031", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "0a0dc9bdef", + "context": null, + "text": "platforms should treat fulfillment as a generic, renderable structure", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0032", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "ae5940e52e", + "context": null, + "text": "platforms may provide enhanced ux for recognized method types (store selectors for pickup, carrier logos for shipping), but this is optional", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0033", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "10dcc01036", + "context": null, + "text": "when a buyer selects an option the platform cannot fully process, the platform should use continue_url to hand off to the business's checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0034", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "c3d38466fe", + "context": null, + "text": "if the buyer chooses pickup but the platform doesn't support split fulfillment, the platform should use continue_url to hand off to the business's checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0035", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "c663a9746e", + "context": "fulfillment.methods[] lists the methods available for a variant. each method has", + "text": "a business that advertises pickup at a location must accept that same id as selected_destination_id for that method in checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0036", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "2cf57b7024", + "context": null, + "text": "where a method states availability, consumers must use it for that method", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0037", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "443d2106bc", + "context": null, + "text": "where a method states availability, consumers must not infer per-method availability from the variant-level value", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0038", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "2212f639d3", + "context": null, + "text": "a method may carry options[], a representative subset of its fulfillment options - not an exhaustive list", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0039", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "62d55044f9", + "context": null, + "text": "without a destination or full cart, a business should preview meaningful boundary options for the buyer (e.g. cheapest, fastest); more specific options are negotiated in checkout once the line items and destination are known", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0040", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "a1a4de15f2", + "context": null, + "text": "the option is open, so a business may annotate it with additional fields", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0041", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "185fc4c8c0", + "context": null, + "text": "a method may also carry none, surfacing only type, description, and availability; options are nested directly under the method, with no group layer (unlike checkout methods[].groups[].options[])", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0042", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "417161b1bb", + "context": null, + "text": "a discovered option id lets a buyer's choice carry forward: a business should accept the same id as methods[].groups[].selected_option_id in checkout", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0043", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "f9ed828394", + "context": null, + "text": "on a market-scoped catalog a business may narrow results with these hints; otherwise they annotate results rather than remove them", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0044", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "3a8712da69", + "context": null, + "text": "platforms should provide one or the other, not both", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0045", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "100391f5f5", + "context": null, + "text": "if both are present, a business should use the more specific - typically location", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0046", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "ae3b66a72c", + "context": null, + "text": "a party that does not expose catalog discovery may narrow extends to \"dev.ucp.shopping.checkout\" (string form) or to a single-element array", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0047", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "37e1ff580a", + "context": null, + "text": "opt-in declaration (business may return multiple groups per method)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0048", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "5a0da8cb6d", + "context": "when supports_multi_group: false (default)", + "text": "business must consolidate all items into a single group per method", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0049", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "f390899b31", + "context": "when supports_multi_group: false (default)", + "text": "business may still return multiple methods (e.g., shipping + pickup) if cart items require it", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0050", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "ea0855e957", + "context": "when supports_multi_group: true", + "text": "business may return multiple groups per method based on inventory, packaging, or warehouse logic", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0051", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "746f0c1c71", + "context": null, + "text": "presentation is method-agnostic: platforms should present every method, rendering description and availability regardless of its type (see rendering)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0052", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "f3e16becc1", + "context": null, + "text": "presentation is method-agnostic: platforms should not omit a method solely because they do not recognize its type", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0053", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "79e7a637e6", + "context": null, + "text": "a business should model same-scope variation (e.g. standard vs express) as options", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0054", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "15788b383d", + "context": null, + "text": "a business should not emit multiple methods that differ only in option-level detail", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0055", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "378c4f8068", + "context": null, + "text": "adding method types. because type is an open string, a business may introduce a new value at any time with no consumer change: it advertises the value (and filters on it via filters.methods), and consumers present it like any other method", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0056", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "adb26a1879", + "context": "for ordering", + "text": "platforms should render options in the provided order", + "previous_digests": [ + "08886e0103" + ], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0057", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "7ea8962c4d", + "context": null, + "text": "extensions that extend fulfillment with new method types (e.g., local_delivery) must add an extension schema that", + "previous_digests": [], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-ORDER-0001", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "db110c82c0", + "context": "line items - what was purchased at checkout", + "text": "must include all line items that ever existed on the order regardless of edits or alterations", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0002", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "cc3d0c0f7a", + "context": "adjustments - post-order events independent of fulfillment", + "text": "businesses should append new entries rather than mutating existing ones; append-only ledger is preferred", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0003", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "680173e292", + "context": "adjustments - post-order events independent of fulfillment", + "text": "businesses that do not maintain adjustment history may perform in-place updates of existing entries (e.g. a single return adjustment can transition from pending to completed)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0004", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "5e0b5a836c", + "context": null, + "text": "businesses may surface a snapshot of the originating checkout's attribution on the order", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0005", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "f650fb481d", + "context": null, + "text": "businesses may surface a snapshot of the policies that applied at checkout on the order", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0006", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "b3887dba91", + "context": null, + "text": "when the price settles against an actual measurement, the adjustment must carry the settled measure", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0007", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "7e7fe0b12a", + "context": null, + "text": "its unit identity must match the pricing basis (no conversion), and a pure price settlement uses quantity: 0 so the count is untouched. (a settled measure is business-recorded fact", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0008", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "8259428a26", + "context": null, + "text": "businesses must return the full order entity on every response", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0009", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "5f3bf1ba25", + "context": null, + "text": "the business must authenticate requests to order data before returning a response, using any supported ucp mechanism - api keys, oauth 2.0, mutual tls, or http message signatures (see identity and authentication)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0010", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "68f3d605bf", + "context": null, + "text": "platform credentials (api key, signatures, oauth client credentials) - businesses may allow access for orders the platform originated", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0011", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "7562bd96a3", + "context": null, + "text": "businesses may define additional access policies (e.g., trusted partner agreements), enforce data availability constraints (e.g., retention windows, regulatory erasure), and omit or redact optional fields from the response based on context, business policy, or other requirements - independently of authorization", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0012", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "d79ebec396", + "context": "platform", + "text": "must include ucp-agent header with profile url on all requests", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0013", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "8fb9d0d3c3", + "context": "platform", + "text": "should rely on webhooks (see events) as the primary order update channel and use get order for reconciliation or on-demand retrieval", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0014", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "e3b0e4d162", + "context": "platform", + "text": "should treat order data as ephemeral and discard it when no longer needed for active commerce flows", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0015", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "af7faa7edc", + "context": "business", + "text": "must authenticate requests to order data before returning a response (see authorization)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0016", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "6b50b563f9", + "context": null, + "text": "webhook payloads must be signed by the business and verified by the platform to ensure authenticity and integrity", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0017", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "22a6667ade", + "context": null, + "text": "platforms should deduplicate on webhook-id, which short-circuits retries and separates events that share a webhook-timestamp, whose resolution is one second", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0018", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "2bc16e17be", + "context": null, + "text": "businesses must send retries with the original webhook-id and webhook-timestamp: a retry redelivers the same event, and the deduplication and ordering above rely on both values staying constant", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0019", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "0392cffe09", + "context": null, + "text": "after verifying the signature, the platform must confirm the signer is authorized to send events for the referenced order", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0020", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "f7fb88a8ea", + "context": "platform", + "text": "must respond quickly with a 2xx http status code to acknowledge webhook receipt; process events asynchronously after responding", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0021", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "cd10b52eeb", + "context": "business", + "text": "must include ucp-agent header with profile url for signer identification", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0022", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "a5e8107f1f", + "context": "business", + "text": "must sign all webhook payloads per the message signatures specification using rfc 9421 headers (signature, signature-input, content-digest)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0023", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "103d1048ca", + "context": "business", + "text": "must send \"order created\" event with fully populated order entity", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0024", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "4b626e6827", + "context": "business", + "text": "must send full order entity on updates (not incremental deltas)", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0025", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "1f2d85ce9c", + "context": "business", + "text": "must retry failed webhook deliveries", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0026", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "fbd2ccba30", + "context": "business", + "text": "must send retries with the original webhook-id and webhook-timestamp; a retry redelivers the same event, and platforms deduplicate on webhook-id and order deliveries by webhook-timestamp", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0027", + "file": "docs/specification/shopping/order/mcp.md", + "text_digest": "7d9d798bfd", + "context": null, + "text": "mcp clients must include a meta object in every request containing protocol metadata", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0028", + "file": "docs/specification/shopping/order/mcp.md", + "text_digest": "160daf898a", + "context": null, + "text": "platforms may include additional metadata fields", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0029", + "file": "docs/specification/shopping/order/mcp.md", + "text_digest": "dfdf1af93d", + "context": null, + "text": "platforms must check messages before accessing order fields", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0030", + "file": "docs/specification/shopping/order/mcp.md", + "text_digest": "50d0db61d3", + "context": "platforms implementing the mcp binding", + "text": "must include meta.ucp-agent.profile on all requests", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0031", + "file": "docs/specification/shopping/order/mcp.md", + "text_digest": "61b7633392", + "context": "platforms implementing the mcp binding", + "text": "must check the messages array in responses before accessing order data", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0032", + "file": "docs/specification/shopping/order/mcp.md", + "text_digest": "a8dce026f4", + "context": "platforms implementing the mcp binding", + "text": "should delegate to the business via permalink_url for the authoritative order experience - the business site is the source of truth for order details and post-purchase operations", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0033", + "file": "docs/specification/shopping/order/mcp.md", + "text_digest": "62046948e1", + "context": "businesses implementing the mcp binding", + "text": "must implement the get_order tool per the openrpc schema", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0034", + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "de72b2d0de", + "context": null, + "text": "all response bodies must be valid json as specified in rfc 8259", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0035", + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "86f31bc40b", + "context": null, + "text": "all rest endpoints must be served over https with minimum tls version 1.3", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0036", + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "15463fa061", + "context": "platforms implementing the rest binding", + "text": "must include ucp-agent header with profile url on all requests", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0037", + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "c299106814", + "context": "platforms implementing the rest binding", + "text": "must check the messages array in responses before accessing order data", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0038", + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "a6262d6e2e", + "context": "platforms implementing the rest binding", + "text": "should delegate to the business via permalink_url for the authoritative order experience - the business site is the source of truth for order details and post-purchase operations", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0039", + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "10eaedb9f9", + "context": "businesses implementing the rest binding", + "text": "must serve all endpoints over https with tls 1.3+", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0040", + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "f797370582", + "context": "businesses implementing the rest binding", + "text": "should sign responses per the message signatures specification", + "previous_digests": [], + "status": "active", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": null + }, + { + "id": "REQ-SHOPPING-ORDER-0041", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "92ea191b2b", + "context": "platform", + "text": "must respond quickly with a 2xx http status code to acknowledge receipt", + "previous_digests": [ + "de55178249" + ], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-ORDER-0042", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "0531f624a3", + "context": "business", + "text": "must sign all webhook payloads using a key from their signing_keys array (published in /.well-known/ucp)", + "previous_digests": [ + "618f425437" + ], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-ORDER-0043", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "f4c2f03458", + "context": "business", + "text": "the signature must be included in the request-signature header as a detached jwt (rfc 7797)", + "previous_digests": [ + "e0936ede0f" + ], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + }, + { + "id": "REQ-SHOPPING-ORDER-0044", + "file": "docs/specification/shopping/order/index.md", + "text_digest": "e27fc7ad69", + "context": "business", + "text": "must include business identifier in webhook path or headers", + "previous_digests": [ + "f1fc3a26a6" + ], + "status": "retired", + "minted_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "retired_at": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1" + } + ] +} diff --git a/requirements/catalog/shopping/cart/embedded.json b/requirements/catalog/shopping/cart/embedded.json new file mode 100644 index 0000000..3c6213b --- /dev/null +++ b/requirements/catalog/shopping/cart/embedded.json @@ -0,0 +1,1547 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/cart/embedded.md", + "summary": { + "total": 28, + "must_count": 16, + "must_not_count": 4, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 3, + "should_not_count": 0, + "may_count": 5, + "by_level": { + "MAY": 5, + "MUST": 16, + "MUST NOT": 4, + "SHOULD": 3 + }, + "by_actor": { + "BUSINESS": 2, + "HOST": 10, + "UNRESOLVED": 16 + }, + "by_file": { + "docs/specification/shopping/cart/embedded.md": 28 + }, + "with_condition": 10, + "with_referenced_fields": 21, + "from_compound_split": 4, + "diagnostics": { + "actor_after_keyword_only": 5, + "actor_low_confidence": 0, + "actor_unresolved": 16, + "annotation_as_obligation": 0, + "annotations_excluded": 14, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 9, + "empty_after_split": 0, + "multi_obligation_sentences": 2, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CART-0030", + "text_digest": "6d177cbebb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MUST** include an embedded service binding with `config.delegate` in cart responses to indicate ECaP availability and allowed delegations for a specific session.", + "normalized": "businesses must include an embedded service binding with config.delegate in cart responses to indicate ecap availability and allowed delegations for a specific session", + "condition": null, + "referenced_fields": [ + "config.delegate" + ], + "compound_parent": null, + "document_order": 14, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 85, + "end_line": 88, + "section": "Cart Capability - EP Binding > Terminology & Actors > Discovery > Per-Cart Configuration", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "per-cart-configuration" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-PER-CART-CONFIGURATION-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": true, + "testable_reason": "reviewed: visible in REST cart responses; applies only to businesses that offer embedded cart", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in REST cart responses; applies only to businesses that offer embedded cart" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 84, + "level": "MUST", + "text_digest": "6d177cbebb" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 85, + "level": "MUST", + "text_digest": "6d177cbebb" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0031", + "text_digest": "3bfce93152", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When a host receives a cart response with a `continue_url` from a business that advertises ECaP support, it **MAY** initiate an ECaP session by loading the URL in an embedded context.", + "normalized": "when a host receives a cart response with a continue_url from a business that advertises ecap support, it may initiate an ecap session by loading the url in an embedded context", + "condition": "When a host receives a cart response with a `continue_url` from a business that advertises ECaP support", + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 16, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 119, + "end_line": 121, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "loading-an-embedded-cart-url" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-LOADING-AN-EMBEDDED-CART-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "reviewed: permission for the host, the sentence's subject", + "review": { + "verdict": "rule", + "actor": "HOST", + "testable": false, + "reason": "permission for the host, the sentence's subject" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 117, + "level": "MAY", + "text_digest": "3bfce93152" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 119, + "level": "MAY", + "text_digest": "3bfce93152" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0032", + "text_digest": "40901b2bee", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "Before loading the embedded context, the host **SHOULD**:", + "normalized": "before loading the embedded context, the host should", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 20, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 131, + "end_line": 131, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "loading-an-embedded-cart-url" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-LOADING-AN-EMBEDDED-CART-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 129, + "level": "SHOULD", + "text_digest": "40901b2bee" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 131, + "level": "SHOULD", + "text_digest": "40901b2bee" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0033", + "text_digest": "1eb6a4ff57", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "To initiate the session, the host **MUST** augment the `continue_url` with supported ECaP query parameters.", + "normalized": "to initiate the session, the host must augment the continue_url with supported ecap query parameters", + "condition": null, + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 23, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 137, + "end_line": 138, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "loading-an-embedded-cart-url" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-LOADING-AN-EMBEDDED-CART-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 135, + "level": "MUST", + "text_digest": "1eb6a4ff57" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 137, + "level": "MUST", + "text_digest": "1eb6a4ff57" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0034", + "text_digest": "99fb03a018", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Parameters **SHOULD** use either `ep` or `ep_cart` prefixes to avoid namespace pollution and clearly distinguish ECaP parameters from business-specific query parameters:", + "normalized": "parameters should use either ep or ep_cart prefixes to avoid namespace pollution and clearly distinguish ecap parameters from business-specific query parameters", + "condition": null, + "referenced_fields": [ + "ep", + "ep_cart" + ], + "compound_parent": null, + "document_order": 25, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 140, + "end_line": 143, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "loading-an-embedded-cart-url" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-LOADING-AN-EMBEDDED-CART-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 138, + "level": "SHOULD", + "text_digest": "99fb03a018" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 140, + "level": "SHOULD", + "text_digest": "99fb03a018" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0035", + "text_digest": "3ef6139abf", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MAY** be empty if no delegations are needed.", + "normalized": "may be empty if no delegations are needed", + "condition": "if no delegations are needed", + "referenced_fields": [], + "compound_parent": "All ECaP parameters are passed via URL query string, not HTTP headers, to ensure maximum compatibility across different embedding environments. Parameters **SHOULD** use either `ep` or `ep_cart` prefixes to avoid namespace pollution and clearly distinguish ECaP parameters from business-specific query parameters:", + "document_order": 39, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 152, + "end_line": 154, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "block_type": "list_item", + "page": "specification/shopping/cart/embedded/", + "anchor": "loading-an-embedded-cart-url" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-LOADING-AN-EMBEDDED-CART-05", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 150, + "level": "MAY", + "text_digest": "3ef6139abf" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 152, + "level": "MAY", + "text_digest": "3ef6139abf" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0036", + "text_digest": "dde250e17d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**SHOULD** be a subset of `config.delegate` from the embedded service binding.", + "normalized": "should be a subset of config.delegate from the embedded service binding", + "condition": null, + "referenced_fields": [ + "config.delegate" + ], + "compound_parent": "All ECaP parameters are passed via URL query string, not HTTP headers, to ensure maximum compatibility across different embedding environments. Parameters **SHOULD** use either `ep` or `ep_cart` prefixes to avoid namespace pollution and clearly distinguish ECaP parameters from business-specific query parameters:", + "document_order": 40, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 152, + "end_line": 154, + "section": "Cart Capability - EP Binding > Terminology & Actors > Loading an Embedded Cart URL", + "block_type": "list_item", + "page": "specification/shopping/cart/embedded/", + "anchor": "loading-an-embedded-cart-url" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-LOADING-AN-EMBEDDED-CART-06", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 150, + "level": "SHOULD", + "text_digest": "dde250e17d" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 152, + "level": "SHOULD", + "text_digest": "dde250e17d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0037", + "text_digest": "9854f1f8d0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The `ucp.version` in all responses **MUST** echo the `ep_version` negotiated during session initialization and confirmed by the host in the `ep.cart.ready` response.", + "normalized": "the ucp.version in all responses must echo the ep_version negotiated during session initialization and confirmed by the host in the ep.cart.ready response", + "condition": null, + "referenced_fields": [ + "ep.cart.ready", + "ep_version", + "ucp.version" + ], + "compound_parent": null, + "document_order": 43, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 162, + "end_line": 165, + "section": "Cart Capability - EP Binding > Transport & Messaging", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "transport-messaging" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-TRANSPORT-MESSAGING-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 160, + "level": "MUST", + "text_digest": "9854f1f8d0" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 162, + "level": "MUST", + "text_digest": "9854f1f8d0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0038", + "text_digest": "22d5406f7a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The version is session-bound — it **MUST NOT** change for the duration of the ECaP session.", + "normalized": "the version is session-bound - it must not change for the duration of the ecap session", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 44, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 162, + "end_line": 165, + "section": "Cart Capability - EP Binding > Transport & Messaging", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "transport-messaging" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-TRANSPORT-MESSAGING-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 160, + "level": "MUST NOT", + "text_digest": "22d5406f7a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 162, + "level": "MUST NOT", + "text_digest": "22d5406f7a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0039", + "text_digest": "236108e3a6", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Core messages are defined by the ECaP specification and **MUST** be supported by all implementations.", + "normalized": "core messages are defined by the ecap specification and must be supported by all implementations", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 51, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 185, + "end_line": 186, + "section": "Cart Capability - EP Binding > Message API Reference > Message Categories > Core Messages", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "core-messages" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-CORE-MESSAGES-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 183, + "level": "MUST", + "text_digest": "236108e3a6" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 185, + "level": "MUST", + "text_digest": "236108e3a6" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0040", + "text_digest": "12e38410dc", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Upon rendering, the Embedded Cart **MUST** broadcast readiness to the parent context using the `ep.cart.ready` message.", + "normalized": "upon rendering, the embedded cart must broadcast readiness to the parent context using the ep.cart.ready message", + "condition": null, + "referenced_fields": [ + "ep.cart.ready" + ], + "compound_parent": null, + "document_order": 72, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 200, + "end_line": 204, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 198, + "level": "MUST", + "text_digest": "12e38410dc" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 200, + "level": "MUST", + "text_digest": "12e38410dc" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0041", + "text_digest": "d081ee92cc", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** be a subset of both `ep_cart_delegate` (what host requested) and `config.delegate` from the cart response (what business allows).", + "normalized": "must be a subset of both ep_cart_delegate (what host requested) and config.delegate from the cart response (what business allows)", + "condition": null, + "referenced_fields": [ + "config.delegate", + "ep_cart_delegate" + ], + "compound_parent": "**Payload:**", + "document_order": 79, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 209, + "end_line": 213, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "list_item", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 207, + "level": "MUST", + "text_digest": "d081ee92cc" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 209, + "level": "MUST", + "text_digest": "d081ee92cc" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0042", + "text_digest": "9f75f5e48f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The `ep.cart.ready` message is a request, which means that the host **MUST** respond to complete the handshake.", + "normalized": "the ep.cart.ready message is a request, which means that the host must respond to complete the handshake", + "condition": null, + "referenced_fields": [ + "ep.cart.ready" + ], + "compound_parent": null, + "document_order": 85, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 237, + "end_line": 238, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 234, + "level": "MUST", + "text_digest": "9f75f5e48f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 237, + "level": "MUST", + "text_digest": "9f75f5e48f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0043", + "text_digest": "2732dd948e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The `version` confirms the negotiated `ep_version` and `status` **MUST** be `\"success\"`.", + "normalized": "the version confirms the negotiated ep_version and status must be \"success\"", + "condition": null, + "referenced_fields": [ + "ep_version", + "status", + "version" + ], + "compound_parent": "**Result Payload:**", + "document_order": 91, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 243, + "end_line": 245, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "list_item", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 240, + "level": "MUST", + "text_digest": "2732dd948e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 243, + "level": "MUST", + "text_digest": "2732dd948e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0044", + "text_digest": "5e3413cd0d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST NOT", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "When present, host **MUST NOT** include `credential` — the channel will be re-established and any credential sent here will be discarded.", + "normalized": "when present, host must not include credential - the channel will be re-established and any credential sent here will be discarded", + "condition": "When present", + "referenced_fields": [ + "credential" + ], + "compound_parent": "**Result Payload:**", + "document_order": 94, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 246, + "end_line": 250, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "list_item", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-05", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 243, + "level": "MUST NOT", + "text_digest": "5e3413cd0d" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 246, + "level": "MUST NOT", + "text_digest": "5e3413cd0d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0045", + "text_digest": "abdc68d4ce", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The requested authorization data, can be in the form of an OAuth token, JWT, API keys, etc. **MUST** be set if `auth` is present in the request.", + "normalized": "the requested authorization data, can be in the form of an oauth token, jwt, api keys, etc. must be set if auth is present in the request", + "condition": "if `auth` is present in the request", + "referenced_fields": [ + "auth" + ], + "compound_parent": "**Result Payload:**", + "document_order": 96, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 251, + "end_line": 254, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "list_item", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-06", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 248, + "level": "MUST", + "text_digest": "abdc68d4ce" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 251, + "level": "MUST", + "text_digest": "abdc68d4ce" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0046", + "text_digest": "8c8a34c733", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST NOT** be set if `upgrade` is present.", + "normalized": "must not be set if upgrade is present", + "condition": "if `upgrade` is present", + "referenced_fields": [ + "upgrade" + ], + "compound_parent": "**Result Payload:**", + "document_order": 97, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 251, + "end_line": 254, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "list_item", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-07", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 248, + "level": "MUST NOT", + "text_digest": "8c8a34c733" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 251, + "level": "MUST NOT", + "text_digest": "8c8a34c733" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0047", + "text_digest": "93c5cfff95", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "Hosts **MAY** respond with an `upgrade` field to update the communication channel between host and Embedded Cart.", + "normalized": "hosts may respond with an upgrade field to update the communication channel between host and embedded cart", + "condition": null, + "referenced_fields": [ + "upgrade" + ], + "compound_parent": null, + "document_order": 99, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 270, + "end_line": 274, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-08", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 266, + "level": "MAY", + "text_digest": "93c5cfff95" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 270, + "level": "MAY", + "text_digest": "93c5cfff95" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0048", + "text_digest": "eb3704265c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Currently, this object only supports a `port` field, which **MUST** be a `MessagePort` object", + "normalized": "currently, this object only supports a port field, which must be a messageport object", + "condition": null, + "referenced_fields": [ + "port" + ], + "compound_parent": null, + "document_order": 100, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 270, + "end_line": 274, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-09", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 266, + "level": "MUST", + "text_digest": "eb3704265c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 270, + "level": "MUST", + "text_digest": "eb3704265c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0049", + "text_digest": "ad6f991ef5", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Currently, this object only supports a `port` field, which **MUST** be transferred to the embedded cart context (e.g., with `{transfer: [port2]}` on the host's `iframe.contentWindow.postMessage()` call)", + "normalized": "currently, this object only supports a port field, which must be transferred to the embedded cart context (e.g., with {transfer: [port2]} on the host's iframe.contentwindow.postmessage() call)", + "condition": null, + "referenced_fields": [ + "port" + ], + "compound_parent": null, + "document_order": 100, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 270, + "end_line": 274, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-10", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 266, + "level": "MUST", + "text_digest": "ad6f991ef5" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 270, + "level": "MUST", + "text_digest": "ad6f991ef5" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0050", + "text_digest": "8c0d70a15b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "When the host responds with an `upgrade` object, the Embedded Cart **MUST** discard any other information in the message, send a new `ep.cart.ready` message over the upgraded communication channel, and wait for a new response.", + "normalized": "when the host responds with an upgrade object, the embedded cart must discard any other information in the message, send a new ep.cart.ready message over the upgraded communication channel, and wait for a new response", + "condition": "When the host responds with an `upgrade` object", + "referenced_fields": [ + "ep.cart.ready", + "upgrade" + ], + "compound_parent": null, + "document_order": 102, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 292, + "end_line": 296, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-11", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 287, + "level": "MUST", + "text_digest": "8c0d70a15b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 292, + "level": "MUST", + "text_digest": "8c0d70a15b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0051", + "text_digest": "a809664137", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "All subsequent messages **MUST** be sent only over the upgraded communication channel.", + "normalized": "all subsequent messages must be sent only over the upgraded communication channel", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 103, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 292, + "end_line": 296, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-12", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 287, + "level": "MUST", + "text_digest": "a809664137" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 292, + "level": "MUST", + "text_digest": "a809664137" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0052", + "text_digest": "b4ddfaed6e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "If the host cannot complete the handshake (e.g., origin validation failure or protocol state violation), it **MUST** respond with an `error_response` result.", + "normalized": "if the host cannot complete the handshake (e.g., origin validation failure or protocol state violation), it must respond with an error_response result", + "condition": "If the host cannot complete the handshake (e.g., origin validation failure or protocol state violation)", + "referenced_fields": [ + "error_response" + ], + "compound_parent": null, + "document_order": 104, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 298, + "end_line": 303, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-13", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 293, + "level": "MUST", + "text_digest": "b4ddfaed6e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 298, + "level": "MUST", + "text_digest": "b4ddfaed6e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0053", + "text_digest": "dfcef5c6f2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **MUST** tear down the embedded context", + "normalized": "the host must tear down the embedded context", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 106, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 298, + "end_line": 303, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-14", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 293, + "level": "MUST", + "text_digest": "dfcef5c6f2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 298, + "level": "MUST", + "text_digest": "dfcef5c6f2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0054", + "text_digest": "c45fb9f3f1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **MAY** redirect the buyer to `continue_url` if present.", + "normalized": "the host may redirect the buyer to continue_url if present", + "condition": "if present", + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 106, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 298, + "end_line": 303, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-15", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 293, + "level": "MAY", + "text_digest": "c45fb9f3f1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 298, + "level": "MAY", + "text_digest": "c45fb9f3f1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0055", + "text_digest": "55ae656dbf", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The Embedded Cart **MUST NOT** send further messages after receiving a handshake error.", + "normalized": "the embedded cart must not send further messages after receiving a handshake error", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 107, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 298, + "end_line": 303, + "section": "Cart Capability - EP Binding > Message API Reference > Handshake Messages > `ep.cart.ready`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartready" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-READY-16", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 293, + "level": "MUST NOT", + "text_digest": "55ae656dbf" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 298, + "level": "MUST NOT", + "text_digest": "55ae656dbf" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0056", + "text_digest": "2f6da07657", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When error escalation is required, Embedded Cart **MUST** issue an `ep.cart.error` notification per the [session error pattern](../../embedded-protocol.md#session-error).", + "normalized": "when error escalation is required, embedded cart must issue an ep.cart.error notification per the session error pattern", + "condition": "When error escalation is required", + "referenced_fields": [ + "ep.cart.error" + ], + "compound_parent": null, + "document_order": 112, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 316, + "end_line": 318, + "section": "Cart Capability - EP Binding > Message API Reference > Authentication > `ep.cart.auth`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartauth" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-AUTH-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 311, + "level": "MUST", + "text_digest": "2f6da07657" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 316, + "level": "MUST", + "text_digest": "2f6da07657" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0057", + "text_digest": "431af45a47", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "If `dev.ucp.shopping.checkout` is part of the negotiated capabilities during service discovery, host **MAY** proceed to initiate a checkout session based on the completed cart by issuing a [create checkout](../checkout/index.md#create-checkout) operation.", + "normalized": "if dev.ucp.shopping.checkout is part of the negotiated capabilities during service discovery, host may proceed to initiate a checkout session based on the completed cart by issuing a create checkout operation", + "condition": "If `dev.ucp.shopping.checkout` is part of the negotiated capabilities during service discovery", + "referenced_fields": [ + "dev.ucp.shopping.checkout" + ], + "compound_parent": null, + "document_order": 125, + "source": { + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 361, + "end_line": 364, + "section": "Cart Capability - EP Binding > Message API Reference > Lifecycle Messages > `ep.cart.complete`", + "block_type": "paragraph", + "page": "specification/shopping/cart/embedded/", + "anchor": "epcartcomplete" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-EP-EP-CART-COMPLETE-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-cart.md", + "start_line": 355, + "level": "MAY", + "text_digest": "431af45a47" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/embedded.md", + "start_line": 361, + "level": "MAY", + "text_digest": "431af45a47" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/cart/index.json b/requirements/catalog/shopping/cart/index.json new file mode 100644 index 0000000..e039de3 --- /dev/null +++ b/requirements/catalog/shopping/cart/index.json @@ -0,0 +1,1590 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/cart/index.md", + "summary": { + "total": 29, + "must_count": 6, + "must_not_count": 2, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 12, + "should_not_count": 0, + "may_count": 9, + "by_level": { + "MAY": 9, + "MUST": 6, + "MUST NOT": 2, + "SHOULD": 12 + }, + "by_actor": { + "BUSINESS": 14, + "PLATFORM": 11, + "UNRESOLVED": 4 + }, + "by_file": { + "docs/specification/shopping/cart/index.md": 29 + }, + "with_condition": 9, + "with_referenced_fields": 11, + "from_compound_split": 4, + "diagnostics": { + "actor_after_keyword_only": 1, + "actor_low_confidence": 10, + "actor_unresolved": 4, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 1, + "empty_after_split": 0, + "multi_obligation_sentences": 2, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CART-0001", + "text_digest": "94c63ccb74", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Because the cart checkout extension composes onto the base Checkout schema, `line_items` remains a required request field; the platform MUST include line_items", + "normalized": "because the cart checkout extension composes onto the base checkout schema, line_items remains a required request field; the platform must include line_items", + "condition": null, + "referenced_fields": [ + "line_items" + ], + "compound_parent": null, + "document_order": 38, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 67, + "end_line": 71, + "section": "Cart Capability > Cart-to-Checkout Conversion", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "cart-to-checkout-conversion" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-CART-TO-CHECKOUT-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "draft", + "releases": [] + } + }, + { + "id": "REQ-SHOPPING-CART-0002", + "text_digest": "f2b0ac0e44", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Because the cart checkout extension composes onto the base Checkout schema, `line_items` remains a required request field; the platform SHOULD set it to an empty array (`\"line_items\": []`). array (`\"line_items\": []`).", + "normalized": "because the cart checkout extension composes onto the base checkout schema, line_items remains a required request field; the platform should set it to an empty array (\"line_items\": []). array (\"line_items\": [])", + "condition": null, + "referenced_fields": [ + "line_items" + ], + "compound_parent": null, + "document_order": 38, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 67, + "end_line": 71, + "section": "Cart Capability > Cart-to-Checkout Conversion", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "cart-to-checkout-conversion" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-CART-TO-CHECKOUT-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform", + "note": "spec typo: cart/index.md repeats 'array (`\"line_items\": []`).' across lines 68-69" + }, + "since": "draft", + "releases": [] + } + }, + { + "id": "REQ-SHOPPING-CART-0003", + "text_digest": "cbf1d2e8f8", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The business MUST use the cart contents", + "normalized": "the business must use the cart contents", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 39, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 67, + "end_line": 71, + "section": "Cart Capability > Cart-to-Checkout Conversion", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "cart-to-checkout-conversion" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-CART-TO-CHECKOUT-03", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: a checkout created from a cart reflects the cart's contents", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "a checkout created from a cart reflects the cart's contents" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 66, + "level": "MUST", + "text_digest": "f7ee20ccd2", + "clause": "Business MUST use cart contents" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 67, + "level": "MUST", + "text_digest": "f7ee20ccd2", + "clause": "Business MUST use cart contents" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0004", + "text_digest": "224effb21d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The business MUST ignore overlapping fields in the checkout payload.", + "normalized": "the business must ignore overlapping fields in the checkout payload", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 39, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 67, + "end_line": 71, + "section": "Cart Capability > Cart-to-Checkout Conversion", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "cart-to-checkout-conversion" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-CART-TO-CHECKOUT-04", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: conflicting checkout fields are ignored", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: conflicting checkout fields are ignored" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 66, + "level": "MUST", + "text_digest": "f653a5827f", + "clause": "Business MUST ignore overlapping fields in checkout payload." + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 67, + "level": "MUST", + "text_digest": "f653a5827f", + "clause": "Business MUST ignore overlapping fields in checkout payload." + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0005", + "text_digest": "806cb9a689", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "If an incomplete checkout already exists for the given `cart_id`, the business MUST return the existing checkout session rather than creating a new one.", + "normalized": "if an incomplete checkout already exists for the given cart_id, the business must return the existing checkout session rather than creating a new one", + "condition": "If an incomplete checkout already exists for the given `cart_id`", + "referenced_fields": [ + "cart_id" + ], + "compound_parent": null, + "document_order": 42, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 75, + "end_line": 77, + "section": "Cart Capability > Cart-to-Checkout Conversion", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "cart-to-checkout-conversion" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-CART-TO-CHECKOUT-05", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: the same checkout ID comes back", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the same checkout ID comes back" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 72, + "level": "MUST", + "text_digest": "806cb9a689" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 73, + "level": "MUST", + "text_digest": "806cb9a689" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0006", + "text_digest": "7bceaecc6b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When checkout is initialized via `cart_id`, the cart and checkout sessions SHOULD be linked for the duration of the checkout.", + "normalized": "when checkout is initialized via cart_id, the cart and checkout sessions should be linked for the duration of the checkout", + "condition": "When checkout is initialized via `cart_id`", + "referenced_fields": [ + "cart_id" + ], + "compound_parent": null, + "document_order": 45, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 81, + "end_line": 82, + "section": "Cart Capability > Cart-to-Checkout Conversion", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "cart-to-checkout-conversion" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-CART-TO-CHECKOUT-06", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: business behavior, but 'linked' is only visible indirectly (through the next rule)", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "business behavior, but 'linked' is only visible indirectly (through the next rule)" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 78, + "level": "SHOULD", + "text_digest": "7bceaecc6b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 79, + "level": "SHOULD", + "text_digest": "7bceaecc6b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0007", + "text_digest": "c0e93a9c7b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "**During active checkout** — Business SHOULD maintain the cart and reflect relevant checkout modifications (quantity changes, item removals) back to the cart.", + "normalized": "during active checkout - business should maintain the cart and reflect relevant checkout modifications (quantity changes, item removals) back to the cart", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 46, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 84, + "end_line": 87, + "section": "Cart Capability > Cart-to-Checkout Conversion", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "cart-to-checkout-conversion" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-CART-TO-CHECKOUT-07", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: the cart reflects checkout changes", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the cart reflects checkout changes" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 81, + "level": "SHOULD", + "text_digest": "c0e93a9c7b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 82, + "level": "SHOULD", + "text_digest": "c0e93a9c7b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0008", + "text_digest": "eb1bb7f6a1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "**After checkout completion** — Business MAY clear the cart based on TTL, completion of the checkout, or other business logic.", + "normalized": "after checkout completion - business may clear the cart based on ttl, completion of the checkout, or other business logic", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 48, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 89, + "end_line": 92, + "section": "Cart Capability > Cart-to-Checkout Conversion", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "cart-to-checkout-conversion" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-CART-TO-CHECKOUT-08", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; visible when used", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 86, + "level": "MAY", + "text_digest": "eb1bb7f6a1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 87, + "level": "MAY", + "text_digest": "eb1bb7f6a1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0009", + "text_digest": "270ff2319a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MAY** include `item.quantity_unit` to assert the sale-basis identity.", + "normalized": "the platform may include item.quantity_unit to assert the sale-basis identity", + "condition": null, + "referenced_fields": [ + "item.quantity_unit" + ], + "compound_parent": null, + "document_order": 55, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 103, + "end_line": 107, + "section": "Cart Capability > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-QUANTITY-AND-SALE-BASIS-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 101, + "level": "MAY", + "text_digest": "270ff2319a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0010", + "text_digest": "b06903616a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST NOT", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MUST NOT** treat an outstanding Action as a reason to reject an unrelated cart operation.", + "normalized": "the business must not treat an outstanding action as a reason to reject an unrelated cart operation", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 62, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 121, + "end_line": 124, + "section": "Cart Capability > Actions", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "actions" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-ACTIONS-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 119, + "level": "MUST NOT", + "text_digest": "b06903616a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0011", + "text_digest": "8aadc86b6f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MAY** continue to add, remove, and update items while an Action is outstanding.", + "normalized": "the platform may continue to add, remove, and update items while an action is outstanding", + "condition": "while an Action is outstanding", + "referenced_fields": [], + "compound_parent": null, + "document_order": 63, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 121, + "end_line": 124, + "section": "Cart Capability > Actions", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "actions" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-ACTIONS-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 119, + "level": "MAY", + "text_digest": "8aadc86b6f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0012", + "text_digest": "43243fdbc1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "After processing an Action, the Platform **SHOULD** use [Get Cart](#get-cart) or a subsequent update response to obtain the latest Cart.", + "normalized": "after processing an action, the platform should use get cart or a subsequent update response to obtain the latest cart", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 64, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 126, + "end_line": 127, + "section": "Cart Capability > Actions", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "actions" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-ACTIONS-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 124, + "level": "SHOULD", + "text_digest": "43243fdbc1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0013", + "text_digest": "ee96ea27c0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "**MAY** use carts for pre-purchase exploration and session persistence.", + "normalized": "may use carts for pre-purchase exploration and session persistence", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 69, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 145, + "end_line": 145, + "section": "Cart Capability > Guidelines > Platform", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "platform" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-PLATFORM-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 107, + "level": "MAY", + "text_digest": "ee96ea27c0" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 143, + "level": "MAY", + "text_digest": "ee96ea27c0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0014", + "text_digest": "e9a222cc67", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "**SHOULD** convert cart to checkout when user expresses purchase intent.", + "normalized": "should convert cart to checkout when user expresses purchase intent", + "condition": "when user expresses purchase intent", + "referenced_fields": [], + "compound_parent": null, + "document_order": 70, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 146, + "end_line": 146, + "section": "Cart Capability > Guidelines > Platform", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "platform" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-PLATFORM-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 108, + "level": "SHOULD", + "text_digest": "e9a222cc67" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 144, + "level": "SHOULD", + "text_digest": "e9a222cc67" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0015", + "text_digest": "a44182f239", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "**MAY** display `continue_url` for handoff to business UI.", + "normalized": "may display continue_url for handoff to business ui", + "condition": null, + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 71, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 147, + "end_line": 147, + "section": "Cart Capability > Guidelines > Platform", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "platform" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-PLATFORM-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 109, + "level": "MAY", + "text_digest": "a44182f239" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 145, + "level": "MAY", + "text_digest": "a44182f239" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0016", + "text_digest": "fd4476d57f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "**SHOULD** handle `not_found` gracefully when cart expires or is canceled.", + "normalized": "should handle not_found gracefully when cart expires or is canceled", + "condition": "when cart expires or is canceled", + "referenced_fields": [ + "not_found" + ], + "compound_parent": null, + "document_order": 72, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 148, + "end_line": 148, + "section": "Cart Capability > Guidelines > Platform", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "platform" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-PLATFORM-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 110, + "level": "SHOULD", + "text_digest": "fd4476d57f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 146, + "level": "SHOULD", + "text_digest": "fd4476d57f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0017", + "text_digest": "a865390d42", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**SHOULD** provide `continue_url` for cart handoff and session recovery.", + "normalized": "should provide continue_url for cart handoff and session recovery", + "condition": null, + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 73, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 152, + "end_line": 152, + "section": "Cart Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-BUSINESS-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 114, + "level": "SHOULD", + "text_digest": "a865390d42" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 150, + "level": "SHOULD", + "text_digest": "a865390d42" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0018", + "text_digest": "58b0c041a9", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**SHOULD** provide estimated totals when calculable.", + "normalized": "should provide estimated totals when calculable", + "condition": "when calculable", + "referenced_fields": [], + "compound_parent": null, + "document_order": 75, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 154, + "end_line": 154, + "section": "Cart Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-BUSINESS-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 116, + "level": "SHOULD", + "text_digest": "58b0c041a9" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 152, + "level": "SHOULD", + "text_digest": "58b0c041a9" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0019", + "text_digest": "917c61cb95", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**MAY** omit fulfillment totals until checkout when address is unknown.", + "normalized": "may omit fulfillment totals until checkout when address is unknown", + "condition": "when address is unknown", + "referenced_fields": [], + "compound_parent": null, + "document_order": 76, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 155, + "end_line": 155, + "section": "Cart Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-BUSINESS-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 117, + "level": "MAY", + "text_digest": "917c61cb95" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 153, + "level": "MAY", + "text_digest": "917c61cb95" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0020", + "text_digest": "02d0f50b5c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**SHOULD** return informational messages for validation warnings.", + "normalized": "should return informational messages for validation warnings", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 77, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 156, + "end_line": 156, + "section": "Cart Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-BUSINESS-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 118, + "level": "SHOULD", + "text_digest": "02d0f50b5c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 154, + "level": "SHOULD", + "text_digest": "02d0f50b5c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0021", + "text_digest": "f7f262706c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**MAY** set cart expiry via `expires_at`.", + "normalized": "may set cart expiry via expires_at", + "condition": null, + "referenced_fields": [ + "expires_at" + ], + "compound_parent": null, + "document_order": 78, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 157, + "end_line": 157, + "section": "Cart Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-BUSINESS-05", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 119, + "level": "MAY", + "text_digest": "f7f262706c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 155, + "level": "MAY", + "text_digest": "f7f262706c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0022", + "text_digest": "ffbb6a7174", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**SHOULD** follow [cart lifecycle requirements](#cart-to-checkout-conversion) when checkout is initialized via `cart_id`.", + "normalized": "should follow cart lifecycle requirements when checkout is initialized via cart_id", + "condition": "when checkout is initialized via `cart_id`", + "referenced_fields": [ + "cart_id" + ], + "compound_parent": null, + "document_order": 79, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 158, + "end_line": 159, + "section": "Cart Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/cart/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-BUSINESS-06", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 120, + "level": "SHOULD", + "text_digest": "ffbb6a7174" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 156, + "level": "SHOULD", + "text_digest": "ffbb6a7174" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0023", + "text_digest": "1376be1e26", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When **all** requested items are unavailable, the business MAY return an error response instead of creating a cart resource.", + "normalized": "when all requested items are unavailable, the business may return an error response instead of creating a cart resource", + "condition": "When all requested items are unavailable", + "referenced_fields": [], + "compound_parent": null, + "document_order": 91, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 181, + "end_line": 184, + "section": "Cart Capability > Operations > Create Cart", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "create-cart" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-CREATE-CART-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; visible when used", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 143, + "level": "MAY", + "text_digest": "1376be1e26" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 179, + "level": "MAY", + "text_digest": "1376be1e26" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0024", + "text_digest": "911557d18f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The platform **MUST** send the entire cart resource.", + "normalized": "the platform must send the entire cart resource", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 100, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 215, + "end_line": 217, + "section": "Cart Capability > Operations > Update Cart", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "update-cart" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-UPDATE-CART-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 176, + "level": "MUST", + "text_digest": "911557d18f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 213, + "level": "MUST", + "text_digest": "911557d18f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0025", + "text_digest": "6e0bf927e2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Business MUST return the cart state before deletion.", + "normalized": "business must return the cart state before deletion", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 105, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 224, + "end_line": 225, + "section": "Cart Capability > Operations > Cancel Cart", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "cancel-cart" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-CANCEL-CART-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible in the cancel response", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in the cancel response" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 185, + "level": "MUST", + "text_digest": "6e0bf927e2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 222, + "level": "MUST", + "text_digest": "6e0bf927e2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0026", + "text_digest": "0fbda2ac13", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Subsequent operations for this cart ID SHOULD return `not_found`.", + "normalized": "subsequent operations for this cart id should return not_found", + "condition": null, + "referenced_fields": [ + "not_found" + ], + "compound_parent": null, + "document_order": 106, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 224, + "end_line": 225, + "section": "Cart Capability > Operations > Cancel Cart", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "cancel-cart" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-CANCEL-CART-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: later calls return not_found", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: later calls return not_found" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 185, + "level": "SHOULD", + "text_digest": "0fbda2ac13" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 222, + "level": "SHOULD", + "text_digest": "0fbda2ac13" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0027", + "text_digest": "d17ebc6153", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Signal values MUST NOT be buyer-asserted claims.", + "normalized": "signal values must not be buyer-asserted claims", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 119, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 267, + "end_line": 270, + "section": "Cart Capability > Entities > Signals", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "signals" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-SIGNALS-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: signals are supplied by the platform ('platforms provide signals', checkout page)", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "signals are supplied by the platform ('platforms provide signals', checkout page)" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 228, + "level": "MUST NOT", + "text_digest": "d17ebc6153" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 265, + "level": "MUST NOT", + "text_digest": "d17ebc6153" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0028", + "text_digest": "e0b70c9533", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Taxes MAY be included where calculable.", + "normalized": "taxes may be included where calculable", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 128, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 291, + "end_line": 292, + "section": "Cart Capability > Entities > Total", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "total" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-TOTAL-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on the totals the business returns", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on the totals the business returns" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 252, + "level": "MAY", + "text_digest": "e0b70c9533" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 289, + "level": "MAY", + "text_digest": "e0b70c9533" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0029", + "text_digest": "c4f79c54ee", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms SHOULD assume cart totals are estimates; accurate taxes are computed at checkout.", + "normalized": "platforms should assume cart totals are estimates; accurate taxes are computed at checkout", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 129, + "source": { + "file": "docs/specification/shopping/cart/index.md", + "start_line": 291, + "end_line": 292, + "section": "Cart Capability > Entities > Total", + "block_type": "paragraph", + "page": "specification/shopping/cart/", + "anchor": "total" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-TOTAL-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart.md", + "start_line": 252, + "level": "SHOULD", + "text_digest": "c4f79c54ee" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/index.md", + "start_line": 289, + "level": "SHOULD", + "text_digest": "c4f79c54ee" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/cart/mcp.json b/requirements/catalog/shopping/cart/mcp.json new file mode 100644 index 0000000..e211d6a --- /dev/null +++ b/requirements/catalog/shopping/cart/mcp.json @@ -0,0 +1,266 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/cart/mcp.md", + "summary": { + "total": 4, + "must_count": 2, + "must_not_count": 1, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 0, + "should_not_count": 0, + "may_count": 1, + "by_level": { + "MAY": 1, + "MUST": 2, + "MUST NOT": 1 + }, + "by_actor": { + "IMPLEMENTATION": 1, + "PLATFORM": 2, + "UNRESOLVED": 1 + }, + "by_file": { + "docs/specification/shopping/cart/mcp.md": 4 + }, + "with_condition": 0, + "with_referenced_fields": 2, + "from_compound_split": 0, + "diagnostics": { + "actor_after_keyword_only": 0, + "actor_low_confidence": 0, + "actor_unresolved": 1, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 3, + "empty_after_split": 0, + "multi_obligation_sentences": 0, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CART-0058", + "text_digest": "7d9d798bfd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "MCP clients **MUST** include a `meta` object in every request containing protocol metadata:", + "normalized": "mcp clients must include a meta object in every request containing protocol metadata", + "condition": null, + "referenced_fields": [ + "meta" + ], + "compound_parent": null, + "document_order": 3, + "source": { + "file": "docs/specification/shopping/cart/mcp.md", + "start_line": 68, + "end_line": 69, + "section": "Cart Capability - MCP Binding > Protocol Fundamentals > Request Metadata", + "block_type": "paragraph", + "page": "specification/shopping/cart/mcp/", + "anchor": "request-metadata" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-MCP-REQUEST-METADATA-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart-mcp.md", + "start_line": 66, + "level": "MUST", + "text_digest": "7d9d798bfd" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/mcp.md", + "start_line": 68, + "level": "MUST", + "text_digest": "7d9d798bfd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0059", + "text_digest": "160daf898a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **MAY** include additional metadata fields.", + "normalized": "platforms may include additional metadata fields", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 5, + "source": { + "file": "docs/specification/shopping/cart/mcp.md", + "start_line": 91, + "end_line": 93, + "section": "Cart Capability - MCP Binding > Protocol Fundamentals > Request Metadata", + "block_type": "paragraph", + "page": "specification/shopping/cart/mcp/", + "anchor": "request-metadata" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-MCP-REQUEST-METADATA-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart-mcp.md", + "start_line": 88, + "level": "MAY", + "text_digest": "160daf898a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/mcp.md", + "start_line": 91, + "level": "MAY", + "text_digest": "160daf898a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0060", + "text_digest": "27773aeefb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The `cart` object in the request payload **MUST NOT** contain an `id` field.", + "normalized": "the cart object in the request payload must not contain an id field", + "condition": null, + "referenced_fields": [ + "cart", + "id" + ], + "compound_parent": "MCP tools separate resource identification from payload data:", + "document_order": 9, + "source": { + "file": "docs/specification/shopping/cart/mcp.md", + "start_line": 103, + "end_line": 105, + "section": "Cart Capability - MCP Binding > Tools > Identifier Pattern", + "block_type": "list_item", + "page": "specification/shopping/cart/mcp/", + "anchor": "identifier-pattern" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-MCP-IDENTIFIER-PATTERN-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart-mcp.md", + "start_line": 100, + "level": "MUST NOT", + "text_digest": "27773aeefb" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/mcp.md", + "start_line": 103, + "level": "MUST NOT", + "text_digest": "27773aeefb" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0061", + "text_digest": "748fc7ead3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "A conforming MCP transport implementation **MUST**:", + "normalized": "a conforming mcp transport implementation must", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 58, + "source": { + "file": "docs/specification/shopping/cart/mcp.md", + "start_line": 651, + "end_line": 651, + "section": "Cart Capability - MCP Binding > Conformance", + "block_type": "paragraph", + "page": "specification/shopping/cart/mcp/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-MCP-CONFORMANCE-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart-mcp.md", + "start_line": 635, + "level": "MUST", + "text_digest": "748fc7ead3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/mcp.md", + "start_line": 651, + "level": "MUST", + "text_digest": "748fc7ead3" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/cart/rest.json b/requirements/catalog/shopping/cart/rest.json new file mode 100644 index 0000000..ec7f7b3 --- /dev/null +++ b/requirements/catalog/shopping/cart/rest.json @@ -0,0 +1,278 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/cart/rest.md", + "summary": { + "total": 4, + "must_count": 2, + "must_not_count": 0, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 0, + "should_not_count": 0, + "may_count": 2, + "by_level": { + "MAY": 2, + "MUST": 2 + }, + "by_actor": { + "BUSINESS": 1, + "UNRESOLVED": 3 + }, + "by_file": { + "docs/specification/shopping/cart/rest.md": 4 + }, + "with_condition": 2, + "with_referenced_fields": 0, + "from_compound_split": 0, + "diagnostics": { + "actor_after_keyword_only": 0, + "actor_low_confidence": 0, + "actor_unresolved": 3, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 3, + "empty_after_split": 0, + "multi_obligation_sentences": 0, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CART-0062", + "text_digest": "017f445b50", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "All request and response bodies **MUST** be valid JSON as specified in [RFC 8259](https://tools.ietf.org/html/rfc8259){ target=\"_blank\" }.", + "normalized": "all request and response bodies must be valid json as specified in rfc 8259", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 9, + "source": { + "file": "docs/specification/shopping/cart/rest.md", + "start_line": 76, + "end_line": 77, + "section": "Cart Capability - REST Binding > Protocol Fundamentals > Content Types", + "block_type": "paragraph", + "page": "specification/shopping/cart/rest/", + "anchor": "content-types" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-REST-CONTENT-TYPES-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: binds both sides; the response half is visible", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "binds both sides; the response half is visible" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart-rest.md", + "start_line": 74, + "level": "MUST", + "text_digest": "017f445b50" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/rest.md", + "start_line": 76, + "level": "MUST", + "text_digest": "017f445b50" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0063", + "text_digest": "86f31bc40b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "All REST endpoints **MUST** be served over HTTPS with minimum TLS version 1.3.", + "normalized": "all rest endpoints must be served over https with minimum tls version 1.3", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 10, + "source": { + "file": "docs/specification/shopping/cart/rest.md", + "start_line": 81, + "end_line": 81, + "section": "Cart Capability - REST Binding > Protocol Fundamentals > Transport Security", + "block_type": "paragraph", + "page": "specification/shopping/cart/rest/", + "anchor": "transport-security" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-REST-TRANSPORT-SECURITY-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: visible: the endpoint's TLS version", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the endpoint's TLS version", + "note": "the local sample server serves plain HTTP, so it fails this" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart-rest.md", + "start_line": 79, + "level": "MUST", + "text_digest": "86f31bc40b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/rest.md", + "start_line": 81, + "level": "MUST", + "text_digest": "86f31bc40b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0064", + "text_digest": "9655f6d29f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When authentication is required, the REST transport **MAY** use:", + "normalized": "when authentication is required, the rest transport may use", + "condition": "When authentication is required", + "referenced_fields": [], + "compound_parent": null, + "document_order": 81, + "source": { + "file": "docs/specification/shopping/cart/rest.md", + "start_line": 538, + "end_line": 539, + "section": "Cart Capability - REST Binding > Security Considerations > Authentication", + "block_type": "paragraph", + "page": "specification/shopping/cart/rest/", + "anchor": "authentication" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-REST-AUTHENTICATION-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": false, + "testable_reason": "reviewed: a menu of allowed authentication methods; nothing a test can fail", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "a menu of allowed authentication methods; nothing a test can fail" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart-rest.md", + "start_line": 537, + "level": "MAY", + "text_digest": "9655f6d29f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/rest.md", + "start_line": 548, + "level": "MAY", + "text_digest": "9655f6d29f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CART-0065", + "text_digest": "b40d58d234", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.cart" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MAY** require authentication for some operations while leaving others open (e.g., public cart without authentication).", + "normalized": "businesses may require authentication for some operations while leaving others open (e.g., public cart without authentication)", + "condition": "while leaving others open (e.g., public cart without authentication)", + "referenced_fields": [], + "compound_parent": null, + "document_order": 91, + "source": { + "file": "docs/specification/shopping/cart/rest.md", + "start_line": 548, + "end_line": 549, + "section": "Cart Capability - REST Binding > Security Considerations > Authentication", + "block_type": "paragraph", + "page": "specification/shopping/cart/rest/", + "anchor": "authentication" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CART-REST-AUTHENTICATION-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/cart-rest.md", + "start_line": 547, + "level": "MAY", + "text_digest": "b40d58d234" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/cart/rest.md", + "start_line": 558, + "level": "MAY", + "text_digest": "b40d58d234" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/catalog/index.json b/requirements/catalog/shopping/catalog/index.json new file mode 100644 index 0000000..fbd860e --- /dev/null +++ b/requirements/catalog/shopping/catalog/index.json @@ -0,0 +1,1914 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/catalog/index.md", + "summary": { + "total": 35, + "must_count": 9, + "must_not_count": 5, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 8, + "should_not_count": 1, + "may_count": 12, + "by_level": { + "MAY": 12, + "MUST": 9, + "MUST NOT": 5, + "SHOULD": 8, + "SHOULD NOT": 1 + }, + "by_actor": { + "AGENT": 1, + "BUSINESS": 19, + "PLATFORM": 7, + "UNRESOLVED": 8 + }, + "by_file": { + "docs/specification/shopping/catalog/index.md": 35 + }, + "with_condition": 6, + "with_referenced_fields": 19, + "from_compound_split": 4, + "diagnostics": { + "actor_after_keyword_only": 2, + "actor_low_confidence": 0, + "actor_unresolved": 8, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 5, + "empty_after_split": 0, + "multi_obligation_sentences": 2, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CATALOG-0001", + "text_digest": "40b521f2a3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "SHOULD NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Responses can be session-specific and **SHOULD NOT** be reused across sessions without re-validation.", + "normalized": "responses can be session-specific and should not be reused across sessions without re-validation", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 23, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 54, + "end_line": 57, + "section": "Catalog Capability > Key Concepts > Relationship to Checkout", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "relationship-to-checkout" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-RELATIONSHIP-TO-CHECKOUT-01", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: about consumers reusing responses", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "about consumers reusing responses" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 51, + "level": "SHOULD NOT", + "text_digest": "40b521f2a3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 54, + "level": "SHOULD NOT", + "text_digest": "40b521f2a3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0002", + "text_digest": "1db3a3f0bd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MAY** provide `quantity_unit`, `unit_price`, both, or neither on a variant.", + "normalized": "the business may provide quantity_unit, unit_price, both, or neither on a variant", + "condition": null, + "referenced_fields": [ + "quantity_unit", + "unit_price" + ], + "compound_parent": null, + "document_order": 40, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 97, + "end_line": 102, + "section": "Catalog Capability > Sale basis and quantity units > Distinction from unit price", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "distinction-from-unit-price" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-DISTINCTION-FROM-UNIT-01", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 97, + "level": "MAY", + "text_digest": "1db3a3f0bd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0003", + "text_digest": "ee324c49fb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "To keep the display comparator defined, the Business **MUST** use a positive integer for both `unit_price.measure.value` and `unit_price.reference.value`.", + "normalized": "to keep the display comparator defined, the business must use a positive integer for both unit_price.measure.value and unit_price.reference.value", + "condition": null, + "referenced_fields": [ + "unit_price.measure.value", + "unit_price.reference.value" + ], + "compound_parent": null, + "document_order": 41, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "end_line": 112, + "section": "Catalog Capability > Sale basis and quantity units > Distinction from unit price", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "distinction-from-unit-price" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-DISTINCTION-FROM-UNIT-02", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "level": "MUST", + "text_digest": "ee324c49fb" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0004", + "text_digest": "fb6e4f7181", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MUST** set `unit_price.currency` equal to `price.currency`.", + "normalized": "the business must set unit_price.currency equal to price.currency", + "condition": null, + "referenced_fields": [ + "price.currency", + "unit_price.currency" + ], + "compound_parent": null, + "document_order": 42, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "end_line": 112, + "section": "Catalog Capability > Sale basis and quantity units > Distinction from unit price", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "distinction-from-unit-price" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-DISTINCTION-FROM-UNIT-03", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "level": "MUST", + "text_digest": "fb6e4f7181" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0005", + "text_digest": "5593fc2913", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Within `unit_price`, the Business **MUST** use identical values for `measure.unit` and `reference.unit`.", + "normalized": "within unit_price, the business must use identical values for measure.unit and reference.unit", + "condition": null, + "referenced_fields": [ + "measure.unit", + "reference.unit", + "unit_price" + ], + "compound_parent": null, + "document_order": 43, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "end_line": 112, + "section": "Catalog Capability > Sale basis and quantity units > Distinction from unit price", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "distinction-from-unit-price" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-DISTINCTION-FROM-UNIT-04", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "level": "MUST", + "text_digest": "5593fc2913" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0006", + "text_digest": "20cb8c2a29", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MAY** use different `scale` values for those measures.", + "normalized": "the business may use different scale values for those measures", + "condition": null, + "referenced_fields": [ + "scale" + ], + "compound_parent": null, + "document_order": 44, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "end_line": 112, + "section": "Catalog Capability > Sale basis and quantity units > Distinction from unit price", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "distinction-from-unit-price" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-DISTINCTION-FROM-UNIT-05", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "level": "MAY", + "text_digest": "20cb8c2a29" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0007", + "text_digest": "41a9ebc50c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST NOT", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MUST NOT** perform cross-unit or currency conversion as part of the unit-price calculation.", + "normalized": "the business must not perform cross-unit or currency conversion as part of the unit-price calculation", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 45, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "end_line": 112, + "section": "Catalog Capability > Sale basis and quantity units > Distinction from unit price", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "distinction-from-unit-price" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-DISTINCTION-FROM-UNIT-06", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "level": "MUST NOT", + "text_digest": "41a9ebc50c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0008", + "text_digest": "e6da3fa860", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MUST** compute the comparator from `price.amount` and those scaled values:", + "normalized": "the business must compute the comparator from price.amount and those scaled values", + "condition": null, + "referenced_fields": [ + "price.amount" + ], + "compound_parent": null, + "document_order": 47, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "end_line": 112, + "section": "Catalog Capability > Sale basis and quantity units > Distinction from unit price", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "distinction-from-unit-price" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-DISTINCTION-FROM-UNIT-07", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 104, + "level": "MUST", + "text_digest": "e6da3fa860" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0009", + "text_digest": "685546d140", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MUST** round the result once to the currency's minor units according to its pricing rules and return it as `unit_price.amount`.", + "normalized": "the business must round the result once to the currency's minor units according to its pricing rules and return it as unit_price.amount", + "condition": null, + "referenced_fields": [ + "unit_price.amount" + ], + "compound_parent": null, + "document_order": 48, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 118, + "end_line": 121, + "section": "Catalog Capability > Sale basis and quantity units > Distinction from unit price", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "distinction-from-unit-price" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-DISTINCTION-FROM-UNIT-08", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 118, + "level": "MUST", + "text_digest": "685546d140" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0010", + "text_digest": "979cf19ab7", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST NOT** recompute it or substitute its own result.", + "normalized": "the platform must not recompute it or substitute its own result", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 50, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 118, + "end_line": 121, + "section": "Catalog Capability > Sale basis and quantity units > Distinction from unit price", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "distinction-from-unit-price" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-DISTINCTION-FROM-UNIT-09", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 118, + "level": "MUST NOT", + "text_digest": "979cf19ab7" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0011", + "text_digest": "b566d9087f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "On transaction lines, presence marks the role: the Business **MUST** echo `unit_price` on any line whose pricing basis differs from its sale basis (see [Checkout — pricing basis](../checkout/index.md#quantity-and-sale-basis)).", + "normalized": "on transaction lines, presence marks the role: the business must echo unit_price on any line whose pricing basis differs from its sale basis (see checkout - pricing basis)", + "condition": null, + "referenced_fields": [ + "unit_price" + ], + "compound_parent": null, + "document_order": 56, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 134, + "end_line": 138, + "section": "Catalog Capability > Sale basis and quantity units > Distinction from unit price", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "distinction-from-unit-price" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-DISTINCTION-FROM-UNIT-10", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 134, + "level": "MUST", + "text_digest": "b566d9087f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0012", + "text_digest": "96e978ebd7", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms MAY geo-detect context from request headers.", + "normalized": "platforms may geo-detect context from request headers", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 62, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 177, + "end_line": 179, + "section": "Catalog Capability > Shared Entities > Context", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-CONTEXT-01", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 60, + "level": "MAY", + "text_digest": "96e978ebd7" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 177, + "level": "MAY", + "text_digest": "96e978ebd7" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0013", + "text_digest": "35b444ee45", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses SHOULD use these values when verified inputs (e.g., shipping address) are absent", + "normalized": "businesses should use these values when verified inputs (e.g., shipping address) are absent", + "condition": "when verified inputs (e.g., shipping address) are absent", + "referenced_fields": [], + "compound_parent": null, + "document_order": 64, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 181, + "end_line": 186, + "section": "Catalog Capability > Shared Entities > Context", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-CONTEXT-02", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible in results when no address is given (weakly)", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in results when no address is given (weakly)" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 64, + "level": "SHOULD", + "text_digest": "35b444ee45" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 181, + "level": "SHOULD", + "text_digest": "35b444ee45" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0014", + "text_digest": "e137bb0b98", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses MAY ignore or down-rank them if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls).", + "normalized": "businesses may ignore or down-rank them if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls)", + "condition": "if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls)", + "referenced_fields": [], + "compound_parent": null, + "document_order": 64, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 181, + "end_line": 186, + "section": "Catalog Capability > Shared Entities > Context", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-CONTEXT-03", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: an internal ranking decision; nothing visible to check", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "an internal ranking decision; nothing visible to check" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 64, + "level": "MAY", + "text_digest": "e137bb0b98" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 181, + "level": "MAY", + "text_digest": "e137bb0b98" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0015", + "text_digest": "d647a85835", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Eligibility and policy enforcement MUST occur at checkout time using binding transaction data.", + "normalized": "eligibility and policy enforcement must occur at checkout time using binding transaction data", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 65, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 181, + "end_line": 186, + "section": "Catalog Capability > Shared Entities > Context", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-CONTEXT-04", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: about where the business enforces policy; no specific response to check", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "about where the business enforces policy; no specific response to check" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 64, + "level": "MUST", + "text_digest": "d647a85835" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 181, + "level": "MUST", + "text_digest": "d647a85835" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0016", + "text_digest": "d33d7257de", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Price filter values are denominated in `context.currency`; when the presentment currency differs, businesses SHOULD convert before applying (see [Price Filter](search.md#price-filter)).", + "normalized": "price filter values are denominated in context.currency; when the presentment currency differs, businesses should convert before applying (see price filter)", + "condition": "when the presentment currency differs", + "referenced_fields": [ + "context.currency" + ], + "compound_parent": null, + "document_order": 67, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 188, + "end_line": 192, + "section": "Catalog Capability > Shared Entities > Context", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-CONTEXT-05", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: price filters in another currency", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: price filters in another currency" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 71, + "level": "SHOULD", + "text_digest": "d33d7257de" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 188, + "level": "SHOULD", + "text_digest": "d33d7257de" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0017", + "text_digest": "f49fb6dcf9", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When `context.eligibility` claims are present, Businesses that accept them **MAY** adjust `price` / `list_price` directly for strikethrough display", + "normalized": "when context.eligibility claims are present, businesses that accept them may adjust price / list_price directly for strikethrough display", + "condition": "When `context.eligibility` claims are present", + "referenced_fields": [ + "context.eligibility", + "list_price", + "price" + ], + "compound_parent": null, + "document_order": 69, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 194, + "end_line": 197, + "section": "Catalog Capability > Shared Entities > Context", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-CONTEXT-06", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 77, + "level": "MAY", + "text_digest": "f49fb6dcf9" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 194, + "level": "MAY", + "text_digest": "f49fb6dcf9" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0018", + "text_digest": "7e656cdd76", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When `context.eligibility` claims are present, Businesses that accept them **MAY** use `messages` with `code: \"eligibility_benefit\"` to attribute the adjustment to a specific claim.", + "normalized": "when context.eligibility claims are present, businesses that accept them may use messages with code: \"eligibility_benefit\" to attribute the adjustment to a specific claim", + "condition": "When `context.eligibility` claims are present", + "referenced_fields": [ + "code", + "context.eligibility", + "messages" + ], + "compound_parent": null, + "document_order": 69, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 194, + "end_line": 197, + "section": "Catalog Capability > Shared Entities > Context", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-CONTEXT-07", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 77, + "level": "MAY", + "text_digest": "7e656cdd76" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 194, + "level": "MAY", + "text_digest": "7e656cdd76" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0019", + "text_digest": "d17ebc6153", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Signal values MUST NOT be buyer-asserted claims.", + "normalized": "signal values must not be buyer-asserted claims", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 72, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 203, + "end_line": 205, + "section": "Catalog Capability > Shared Entities > Signals", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "signals" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SIGNALS-01", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: signals are supplied by the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "signals are supplied by the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 86, + "level": "MUST NOT", + "text_digest": "d17ebc6153" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 203, + "level": "MUST NOT", + "text_digest": "d17ebc6153" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0020", + "text_digest": "31e5f5455d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **SHOULD** return the most relevant variant and media item first — default for lookups, best match based on query and context for search.", + "normalized": "businesses should return the most relevant variant and media item first - default for lookups, best match based on query and context for search", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 80, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 222, + "end_line": 225, + "section": "Catalog Capability > Shared Entities > Product", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "product" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-PRODUCT-01", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 105, + "level": "SHOULD", + "text_digest": "31e5f5455d" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 222, + "level": "SHOULD", + "text_digest": "31e5f5455d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0021", + "text_digest": "def47e598c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **SHOULD** treat the first media item they present as featured.", + "normalized": "platforms should treat the first media item they present as featured", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 81, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 222, + "end_line": 225, + "section": "Catalog Capability > Shared Entities > Product", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "product" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-PRODUCT-02", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 105, + "level": "SHOULD", + "text_digest": "def47e598c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 222, + "level": "SHOULD", + "text_digest": "def47e598c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0022", + "text_digest": "f0f49c3eac", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **SHOULD** return the featured variant media item as the first element.", + "normalized": "businesses should return the featured variant media item as the first element", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 87, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 238, + "end_line": 240, + "section": "Catalog Capability > Shared Entities > Variant", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "variant" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-VARIANT-01", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 121, + "level": "SHOULD", + "text_digest": "f0f49c3eac" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 238, + "level": "SHOULD", + "text_digest": "f0f49c3eac" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0023", + "text_digest": "def47e598c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **SHOULD** treat the first media item they present as featured.", + "normalized": "platforms should treat the first media item they present as featured", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 88, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 238, + "end_line": 240, + "section": "Catalog Capability > Shared Entities > Variant", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "variant" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-VARIANT-02", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 121, + "level": "SHOULD", + "text_digest": "def47e598c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 238, + "level": "SHOULD", + "text_digest": "def47e598c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0024", + "text_digest": "47d4d69eb8", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "A Platform **MUST NOT** reject a product or response because it does not recognize a media item's `type`.", + "normalized": "a platform must not reject a product or response because it does not recognize a media item's type", + "condition": null, + "referenced_fields": [ + "type" + ], + "compound_parent": null, + "document_order": 98, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 261, + "end_line": 265, + "section": "Catalog Capability > Shared Entities > Media", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "media" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-MEDIA-01", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 144, + "level": "MUST NOT", + "text_digest": "47d4d69eb8" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 261, + "level": "MUST NOT", + "text_digest": "47d4d69eb8" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0025", + "text_digest": "50fd9f9ad5", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "It **MAY** present such an item from `preview` and `name`, or omit it.", + "normalized": "it may present such an item from preview and name, or omit it", + "condition": null, + "referenced_fields": [ + "name", + "preview" + ], + "compound_parent": null, + "document_order": 99, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 261, + "end_line": 265, + "section": "Catalog Capability > Shared Entities > Media", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "media" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-MEDIA-02", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: 'it' is the platform presenting media", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "'it' is the platform presenting media" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 144, + "level": "MAY", + "text_digest": "50fd9f9ad5" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 261, + "level": "MAY", + "text_digest": "50fd9f9ad5" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0026", + "text_digest": "e03f1b1b3e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "A Platform **MAY** refuse to load or embed a media URL that does not use the `https` scheme.", + "normalized": "a platform may refuse to load or embed a media url that does not use the https scheme", + "condition": null, + "referenced_fields": [ + "https" + ], + "compound_parent": null, + "document_order": 101, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 267, + "end_line": 268, + "section": "Catalog Capability > Shared Entities > Media", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "media" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-MEDIA-03", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 150, + "level": "MAY", + "text_digest": "e03f1b1b3e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 267, + "level": "MAY", + "text_digest": "e03f1b1b3e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0027", + "text_digest": "2272b4257d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "A Business that provides `sources` **SHOULD** include the rendition at `url`.", + "normalized": "a business that provides sources should include the rendition at url", + "condition": null, + "referenced_fields": [ + "sources", + "url" + ], + "compound_parent": null, + "document_order": 103, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 270, + "end_line": 271, + "section": "Catalog Capability > Shared Entities > Media", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "media" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-MEDIA-04", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 153, + "level": "SHOULD", + "text_digest": "2272b4257d" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 270, + "level": "SHOULD", + "text_digest": "2272b4257d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0028", + "text_digest": "f04858a60f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **SHOULD** make `url` the most broadly decodable rendition, because a Platform that does not select from `sources` loads `url` directly.", + "normalized": "the business should make url the most broadly decodable rendition, because a platform that does not select from sources loads url directly", + "condition": null, + "referenced_fields": [ + "sources", + "url" + ], + "compound_parent": null, + "document_order": 107, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 277, + "end_line": 281, + "section": "Catalog Capability > Shared Entities > Media > Image", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "image" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-IMAGE-01", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 160, + "level": "SHOULD", + "text_digest": "f04858a60f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 277, + "level": "SHOULD", + "text_digest": "f04858a60f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0029", + "text_digest": "6610f50a78", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "A Platform that embeds the player **MUST** isolate it from the Platform's authority: no Platform credentials, no access to Platform APIs or agent tools, no protocol messaging privileges, and no navigation of the host application.", + "normalized": "a platform that embeds the player must isolate it from the platform's authority: no platform credentials, no access to platform apis or agent tools, no protocol messaging privileges, and no navigation of the host application", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 115, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 300, + "end_line": 306, + "section": "Catalog Capability > Shared Entities > Media > External Video", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "external-video" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-EXTERNAL-VIDEO-01", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 183, + "level": "MUST", + "text_digest": "6610f50a78" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 300, + "level": "MUST", + "text_digest": "6610f50a78" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0030", + "text_digest": "972c1b040c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Before embedding, it **MUST** decline the item unless `url` is an absolute `https` URL without userinfo that is not same-site with the Platform.", + "normalized": "before embedding, it must decline the item unless url is an absolute https url without userinfo that is not same-site with the platform", + "condition": "unless `url` is an absolute `https` URL without userinfo that is not same-site with the Platform", + "referenced_fields": [ + "https", + "url" + ], + "compound_parent": null, + "document_order": 116, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 300, + "end_line": 306, + "section": "Catalog Capability > Shared Entities > Media > External Video", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "external-video" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-EXTERNAL-VIDEO-02", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: 'it' is the platform embedding a video", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "'it' is the platform embedding a video" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 183, + "level": "MUST", + "text_digest": "972c1b040c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 300, + "level": "MUST", + "text_digest": "972c1b040c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0031", + "text_digest": "b272585568", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MAY** use the same Action `id` in separate responses; that equality does not identify the same work.", + "normalized": "the business may use the same action id in separate responses; that equality does not identify the same work", + "condition": null, + "referenced_fields": [ + "id" + ], + "compound_parent": null, + "document_order": 134, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 357, + "end_line": 361, + "section": "Catalog Capability > Actions", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "actions" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-ACTIONS-01", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 357, + "level": "MAY", + "text_digest": "b272585568" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0032", + "text_digest": "9525c6155e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "A concrete Action-type contract **MAY** define stronger correlation for its instances.", + "normalized": "a concrete action-type contract may define stronger correlation for its instances", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 135, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 357, + "end_line": 361, + "section": "Catalog Capability > Actions", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "actions" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-ACTIONS-02", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at authors of Action-type contracts", + "review": { + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "aimed at authors of Action-type contracts" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 357, + "level": "MAY", + "text_digest": "9525c6155e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0033", + "text_digest": "1532082837", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Catalog defines no Action lifecycle, polling, or resume behavior; a concrete Action-type contract **MAY** define those behaviors for processing its instances.", + "normalized": "catalog defines no action lifecycle, polling, or resume behavior; a concrete action-type contract may define those behaviors for processing its instances", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 140, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 368, + "end_line": 372, + "section": "Catalog Capability > Actions", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "actions" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-ACTIONS-03", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at authors of Action-type contracts", + "review": { + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "aimed at authors of Action-type contracts" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 368, + "level": "MAY", + "text_digest": "1532082837" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0034", + "text_digest": "950a55324b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST NOT", + "target_actor": "AGENT", + "actor_confidence": 0.9, + "clause": "`get_product` returns `severity: \"unrecoverable\"` when an identifier doesn't resolve; agents MUST NOT retry the same `id` (see the [REST](rest.md#product-not-found) and [MCP](mcp.md#product-not-found) examples).", + "normalized": "get_product returns severity: \"unrecoverable\" when an identifier doesn't resolve; agents must not retry the same id (see the rest and mcp examples)", + "condition": null, + "referenced_fields": [ + "get_product", + "id", + "severity" + ], + "compound_parent": null, + "document_order": 161, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 424, + "end_line": 429, + "section": "Catalog Capability > Messages and Error Handling > Message Types", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "message-types" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-MESSAGE-TYPES-01", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at agents", + "review": { + "verdict": "rule", + "actor": "AGENT", + "testable": false, + "reason": "aimed at agents" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 424, + "level": "MUST NOT", + "text_digest": "950a55324b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0035", + "text_digest": "440c8529d2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The response MAY include informational messages indicating which identifiers were not found.", + "normalized": "the response may include informational messages indicating which identifiers were not found", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 172, + "source": { + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 504, + "end_line": 506, + "section": "Catalog Capability > Messages and Error Handling > Common Scenarios > Identifiers Not Found", + "block_type": "paragraph", + "page": "specification/shopping/catalog/", + "anchor": "identifiers-not-found" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-IDENTIFIERS-NOT-FOUND-01", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on response content", + "note": "the same sentence appears 4 more times on catalog rest.md and mcp.md" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/index.md", + "start_line": 317, + "level": "MAY", + "text_digest": "440c8529d2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/index.md", + "start_line": 504, + "level": "MAY", + "text_digest": "440c8529d2" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/catalog/lookup.json b/requirements/catalog/shopping/catalog/lookup.json new file mode 100644 index 0000000..a38b8ad --- /dev/null +++ b/requirements/catalog/shopping/catalog/lookup.json @@ -0,0 +1,983 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/catalog/lookup.md", + "summary": { + "total": 16, + "must_count": 7, + "must_not_count": 1, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 3, + "should_not_count": 0, + "may_count": 5, + "by_level": { + "MAY": 5, + "MUST": 7, + "MUST NOT": 1, + "SHOULD": 3 + }, + "by_actor": { + "IMPLEMENTATION": 6, + "UNRESOLVED": 10 + }, + "by_file": { + "docs/specification/shopping/catalog/lookup.md": 16 + }, + "with_condition": 4, + "with_referenced_fields": 6, + "from_compound_split": 2, + "diagnostics": { + "actor_after_keyword_only": 0, + "actor_low_confidence": 0, + "actor_unresolved": 10, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 1, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0001", + "text_digest": "05e08eb33c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "MAY support SKU, handle, URL, etc.", + "normalized": "may support sku, handle, url, etc", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Input** | `lookup_catalog`", + "document_order": 14, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 37, + "end_line": 37, + "section": "Catalog Lookup Capability > Operations", + "block_type": "table_cell", + "page": "specification/shopping/catalog/lookup/", + "anchor": "operations" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-OPERATIONS-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; a table-cell restatement of the lookup identifier rules", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; a table-cell restatement of the lookup identifier rules" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 37, + "level": "MAY", + "text_digest": "05e08eb33c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 37, + "level": "MAY", + "text_digest": "05e08eb33c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0002", + "text_digest": "4d7409c0dd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MUST", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "Implementations MUST support lookup by product ID and variant ID.", + "normalized": "implementations must support lookup by product id and variant id", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 25, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 51, + "end_line": 54, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Supported Identifiers", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "supported-identifiers" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-SUPPORTED-IDENTIFIERS-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: 'implementations' are the business's server", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "'implementations' are the business's server" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 51, + "level": "MUST", + "text_digest": "4d7409c0dd" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 51, + "level": "MUST", + "text_digest": "4d7409c0dd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0003", + "text_digest": "bb0139a517", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MAY", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "Implementations MAY additionally support secondary identifiers such as SKU or handle, provided these are also fields on the returned product object.", + "normalized": "implementations may additionally support secondary identifiers such as sku or handle, provided these are also fields on the returned product object", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 26, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 51, + "end_line": 54, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Supported Identifiers", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "supported-identifiers" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-SUPPORTED-IDENTIFIERS-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; visible when used", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 51, + "level": "MAY", + "text_digest": "bb0139a517" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 51, + "level": "MAY", + "text_digest": "bb0139a517" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0004", + "text_digest": "fddacf45d0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Duplicate identifiers in the request MUST be deduplicated.", + "normalized": "duplicate identifiers in the request must be deduplicated", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 27, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 56, + "end_line": 59, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Supported Identifiers", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "supported-identifiers" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-SUPPORTED-IDENTIFIERS-03", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: the server deduplicates; visible in the response", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "the server deduplicates; visible in the response" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 56, + "level": "MUST", + "text_digest": "fddacf45d0" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 56, + "level": "MUST", + "text_digest": "fddacf45d0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0005", + "text_digest": "1976ef2539", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MAY", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "When an identifier matches multiple products (e.g., a SKU shared across variants), implementations return matching products and MAY limit the result set.", + "normalized": "when an identifier matches multiple products (e.g., a sku shared across variants), implementations return matching products and may limit the result set", + "condition": "When an identifier matches multiple products (e.g., a SKU shared across variants)", + "referenced_fields": [], + "compound_parent": null, + "document_order": 28, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 56, + "end_line": 59, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Supported Identifiers", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "supported-identifiers" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-SUPPORTED-IDENTIFIERS-04", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; visible when used", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 56, + "level": "MAY", + "text_digest": "1976ef2539" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 56, + "level": "MAY", + "text_digest": "1976ef2539" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0006", + "text_digest": "25191003c1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When multiple identifiers resolve to the same product, it MUST be returned once.", + "normalized": "when multiple identifiers resolve to the same product, it must be returned once", + "condition": "When multiple identifiers resolve to the same product", + "referenced_fields": [], + "compound_parent": null, + "document_order": 29, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 56, + "end_line": 59, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Supported Identifiers", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "supported-identifiers" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-SUPPORTED-IDENTIFIERS-05", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible in the response", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in the response" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 56, + "level": "MUST", + "text_digest": "25191003c1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 56, + "level": "MUST", + "text_digest": "25191003c1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0007", + "text_digest": "67d7d28db3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Variants without an `inputs` entry MUST NOT appear in lookup responses.", + "normalized": "variants without an inputs entry must not appear in lookup responses", + "condition": null, + "referenced_fields": [ + "inputs" + ], + "compound_parent": null, + "document_order": 35, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 68, + "end_line": 72, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Client Correlation", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "client-correlation" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-CLIENT-CORRELATION-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible in the response", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in the response" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 68, + "level": "MUST NOT", + "text_digest": "67d7d28db3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 68, + "level": "MUST NOT", + "text_digest": "67d7d28db3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0008", + "text_digest": "0bedb69a17", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "SHOULD", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "Implementations SHOULD accept at least 10 identifiers per request.", + "normalized": "implementations should accept at least 10 identifiers per request", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 36, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 76, + "end_line": 79, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Batch Size", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "batch-size" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-BATCH-SIZE-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: send 10 identifiers", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: send 10 identifiers" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 76, + "level": "SHOULD", + "text_digest": "0bedb69a17" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 76, + "level": "SHOULD", + "text_digest": "0bedb69a17" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0009", + "text_digest": "1531d8ed95", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MAY", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "Implementations MAY enforce a maximum batch size", + "normalized": "implementations may enforce a maximum batch size", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 37, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 76, + "end_line": 79, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Batch Size", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "batch-size" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-BATCH-SIZE-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; visible through the error", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible through the error" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 76, + "level": "MAY", + "text_digest": "1531d8ed95" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 76, + "level": "MAY", + "text_digest": "1531d8ed95" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0010", + "text_digest": "160c793a93", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MUST", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "Implementations MUST reject requests exceeding their limit with an appropriate error (HTTP 400 `request_too_large` for REST, JSON-RPC `-32602` for MCP).", + "normalized": "implementations must reject requests exceeding their limit with an appropriate error (http 400 request_too_large for rest, json-rpc -32602 for mcp)", + "condition": null, + "referenced_fields": [ + "request_too_large" + ], + "compound_parent": null, + "document_order": 37, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 76, + "end_line": 79, + "section": "Catalog Lookup Capability > Batch Lookup (`lookup_catalog`) > Batch Size", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "batch-size" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-BATCH-SIZE-03", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: HTTP 400 request_too_large", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: HTTP 400 request_too_large" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 76, + "level": "MUST", + "text_digest": "160c793a93" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 76, + "level": "MUST", + "text_digest": "160c793a93" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0011", + "text_digest": "2d2516174f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "`variants` SHOULD contain the featured variant and other variants matching `product.selected`.", + "normalized": "variants should contain the featured variant and other variants matching product.selected", + "condition": null, + "referenced_fields": [ + "product.selected", + "variants" + ], + "compound_parent": "The response returns the product with complete context (title, description, media, options) and a **subset of variants matching [`product.selected`](#option-selection)**:", + "document_order": 54, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 128, + "end_line": 130, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Resolution Behavior", + "block_type": "list_item", + "page": "specification/shopping/catalog/lookup/", + "anchor": "resolution-behavior" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-RESOLUTION-BEHAVIOR-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 128, + "level": "SHOULD", + "text_digest": "2d2516174f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 128, + "level": "SHOULD", + "text_digest": "2d2516174f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0012", + "text_digest": "00e5f417b1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The requested variant MUST be the first element (featured).", + "normalized": "the requested variant must be the first element (featured)", + "condition": null, + "referenced_fields": [], + "compound_parent": "The response returns the product with complete context (title, description, media, options) and a **subset of variants matching [`product.selected`](#option-selection)**:", + "document_order": 57, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 131, + "end_line": 136, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Resolution Behavior", + "block_type": "list_item", + "page": "specification/shopping/catalog/lookup/", + "anchor": "resolution-behavior" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-RESOLUTION-BEHAVIOR-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 131, + "level": "MUST", + "text_digest": "00e5f417b1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 131, + "level": "MUST", + "text_digest": "00e5f417b1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0013", + "text_digest": "50e0b6763f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Each option name MUST appear at most once.", + "normalized": "each option name must appear at most once", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 69, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 154, + "end_line": 156, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Option Selection > Input", + "block_type": "list_item", + "page": "specification/shopping/catalog/lookup/", + "anchor": "input" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-INPUT-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: constrains the `selected` input the client sends", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "constrains the `selected` input the client sends" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 154, + "level": "MUST", + "text_digest": "50e0b6763f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 154, + "level": "MUST", + "text_digest": "50e0b6763f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0014", + "text_digest": "f39f08283c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The response MUST include `product.selected` when the product has configurable options — reflecting the effective selections after any relaxation when the request includes `selected`, or the featured variant's default selections otherwise.", + "normalized": "the response must include product.selected when the product has configurable options - reflecting the effective selections after any relaxation when the request includes selected, or the featured variant's default selections otherwise", + "condition": "when the product has configurable options — reflecting the effective selections after any relaxation when the request includes `selected`, or the featured variant's default selections otherwise", + "referenced_fields": [ + "product.selected", + "selected" + ], + "compound_parent": null, + "document_order": 74, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 164, + "end_line": 168, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Option Selection > Output: Effective Selections", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "output-effective-selections" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-OUTPUT-EFFECTIVE-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 164, + "level": "MUST", + "text_digest": "f39f08283c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 164, + "level": "MUST", + "text_digest": "f39f08283c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0015", + "text_digest": "cc0f65f541", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When the product has no configurable options, `selected` MAY be empty or omitted.", + "normalized": "when the product has no configurable options, selected may be empty or omitted", + "condition": "When the product has no configurable options", + "referenced_fields": [ + "selected" + ], + "compound_parent": null, + "document_order": 75, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 164, + "end_line": 168, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Option Selection > Output: Effective Selections", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "output-effective-selections" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-OUTPUT-EFFECTIVE-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on response content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 164, + "level": "MAY", + "text_digest": "cc0f65f541" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 164, + "level": "MAY", + "text_digest": "cc0f65f541" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-LOOKUP-0016", + "text_digest": "515545af2a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Option values in the response SHOULD include availability signals relative to `product.selected`:", + "normalized": "option values in the response should include availability signals relative to product.selected", + "condition": null, + "referenced_fields": [ + "product.selected" + ], + "compound_parent": null, + "document_order": 81, + "source": { + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 181, + "end_line": 182, + "section": "Catalog Lookup Capability > Get Product (`get_product`) > Option Selection > Output: Availability Signals", + "block_type": "paragraph", + "page": "specification/shopping/catalog/lookup/", + "anchor": "output-availability-signals" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-LOOKUP-LOOKUP-OUTPUT-AVAILABILITY-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/lookup.md", + "start_line": 181, + "level": "SHOULD", + "text_digest": "515545af2a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/lookup.md", + "start_line": 181, + "level": "SHOULD", + "text_digest": "515545af2a" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/catalog/mcp.json b/requirements/catalog/shopping/catalog/mcp.json new file mode 100644 index 0000000..04e3166 --- /dev/null +++ b/requirements/catalog/shopping/catalog/mcp.json @@ -0,0 +1,400 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/catalog/mcp.md", + "summary": { + "total": 6, + "must_count": 3, + "must_not_count": 0, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 0, + "should_not_count": 0, + "may_count": 3, + "by_level": { + "MAY": 3, + "MUST": 3 + }, + "by_actor": { + "BUSINESS": 1, + "IMPLEMENTATION": 1, + "PLATFORM": 1, + "UNRESOLVED": 3 + }, + "by_file": { + "docs/specification/shopping/catalog/mcp.md": 6 + }, + "with_condition": 1, + "with_referenced_fields": 3, + "from_compound_split": 0, + "diagnostics": { + "actor_after_keyword_only": 0, + "actor_low_confidence": 1, + "actor_unresolved": 3, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 0, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CATALOG-0036", + "text_digest": "7d9d798bfd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "MCP clients **MUST** include a `meta` object in every request containing protocol metadata:", + "normalized": "mcp clients must include a meta object in every request containing protocol metadata", + "condition": null, + "referenced_fields": [ + "meta" + ], + "compound_parent": null, + "document_order": 3, + "source": { + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 64, + "end_line": 65, + "section": "Catalog - MCP Binding > Protocol Fundamentals > Request Metadata", + "block_type": "paragraph", + "page": "specification/shopping/catalog/mcp/", + "anchor": "request-metadata" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-MCP-REQUEST-METADATA-01", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/mcp.md", + "start_line": 62, + "level": "MUST", + "text_digest": "7d9d798bfd" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 64, + "level": "MUST", + "text_digest": "7d9d798bfd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0037", + "text_digest": "440c8529d2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The response MAY include informational messages indicating which identifiers were not found.", + "normalized": "the response may include informational messages indicating which identifiers were not found", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 27, + "source": { + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 404, + "end_line": 405, + "section": "Catalog - MCP Binding > Tools > Lookup Response > Partial Success", + "block_type": "paragraph", + "page": "specification/shopping/catalog/mcp/", + "anchor": "partial-success" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-MCP-PARTIAL-SUCCESS-01", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "mcp", + "testable": false, + "testable_reason": "reviewed: MCP binding; the REST page states the same rule", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "MCP binding; the REST page states the same rule" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/mcp.md", + "start_line": 397, + "level": "MAY", + "text_digest": "440c8529d2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 404, + "level": "MAY", + "text_digest": "440c8529d2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0038", + "text_digest": "440c8529d2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "The response MAY include informational messages indicating which identifiers were not found.", + "normalized": "the response may include informational messages indicating which identifiers were not found", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 42, + "source": { + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 740, + "end_line": 742, + "section": "Catalog - MCP Binding > Error Handling > Business Outcomes > Example: All Products Not Found", + "block_type": "paragraph", + "page": "specification/shopping/catalog/mcp/", + "anchor": "example-all-products-not-found" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-MCP-EXAMPLE-ALL-PRODUCTS-NOT-01", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "mcp", + "testable": false, + "testable_reason": "reviewed: MCP binding; the REST page states the same rule", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "MCP binding; the REST page states the same rule" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/mcp.md", + "start_line": 726, + "level": "MAY", + "text_digest": "440c8529d2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 740, + "level": "MAY", + "text_digest": "440c8529d2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0039", + "text_digest": "748fc7ead3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "A conforming MCP transport implementation **MUST**:", + "normalized": "a conforming mcp transport implementation must", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 48, + "source": { + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 792, + "end_line": 792, + "section": "Catalog - MCP Binding > Conformance", + "block_type": "paragraph", + "page": "specification/shopping/catalog/mcp/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-MCP-CONFORMANCE-01", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/mcp.md", + "start_line": 777, + "level": "MUST", + "text_digest": "748fc7ead3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 792, + "level": "MUST", + "text_digest": "748fc7ead3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0040", + "text_digest": "6e5b8536e3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When the Lookup capability is advertised, both `lookup_catalog` and `get_product` tools MUST be available.", + "normalized": "when the lookup capability is advertised, both lookup_catalog and get_product tools must be available", + "condition": "When the Lookup capability is advertised", + "referenced_fields": [ + "get_product", + "lookup_catalog" + ], + "compound_parent": "A conforming MCP transport implementation **MUST**:", + "document_order": 52, + "source": { + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 795, + "end_line": 795, + "section": "Catalog - MCP Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/catalog/mcp/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-MCP-CONFORMANCE-02", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "mcp", + "testable": false, + "testable_reason": "reviewed: MCP binding", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "MCP binding" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/mcp.md", + "start_line": 780, + "level": "MUST", + "text_digest": "6e5b8536e3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 795, + "level": "MUST", + "text_digest": "6e5b8536e3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0041", + "text_digest": "f9a2cc0384", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Return successful result for lookup requests; unknown identifiers result in fewer products returned (MAY include informational `not_found` messages).", + "normalized": "return successful result for lookup requests; unknown identifiers result in fewer products returned (may include informational not_found messages)", + "condition": null, + "referenced_fields": [ + "not_found" + ], + "compound_parent": "A conforming MCP transport implementation **MUST**:", + "document_order": 54, + "source": { + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 797, + "end_line": 797, + "section": "Catalog - MCP Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/catalog/mcp/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-MCP-CONFORMANCE-03", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "mcp", + "testable": false, + "testable_reason": "reviewed: MCP binding", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "MCP binding" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/mcp.md", + "start_line": 782, + "level": "MAY", + "text_digest": "f9a2cc0384" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/mcp.md", + "start_line": 797, + "level": "MAY", + "text_digest": "f9a2cc0384" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/catalog/rest.json b/requirements/catalog/shopping/catalog/rest.json new file mode 100644 index 0000000..af2cc7b --- /dev/null +++ b/requirements/catalog/shopping/catalog/rest.json @@ -0,0 +1,351 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/catalog/rest.md", + "summary": { + "total": 5, + "must_count": 2, + "must_not_count": 0, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 0, + "should_not_count": 0, + "may_count": 3, + "by_level": { + "MAY": 3, + "MUST": 2 + }, + "by_actor": { + "BUSINESS": 1, + "IMPLEMENTATION": 1, + "UNRESOLVED": 3 + }, + "by_file": { + "docs/specification/shopping/catalog/rest.md": 5 + }, + "with_condition": 1, + "with_referenced_fields": 1, + "from_compound_split": 0, + "diagnostics": { + "actor_after_keyword_only": 0, + "actor_low_confidence": 1, + "actor_unresolved": 3, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 0, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CATALOG-0042", + "text_digest": "440c8529d2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The response MAY include informational messages indicating which identifiers were not found.", + "normalized": "the response may include informational messages indicating which identifiers were not found", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 26, + "source": { + "file": "docs/specification/shopping/catalog/rest.md", + "start_line": 293, + "end_line": 295, + "section": "Catalog - REST Binding > Endpoints > `POST /catalog/lookup` > Example: Partial Success (Some Identifiers Not Found)", + "block_type": "paragraph", + "page": "specification/shopping/catalog/rest/", + "anchor": "example-partial-success-some-identifiers-not-found" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-REST-EXAMPLE-PARTIAL-SUCCESS-01", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: permission on REST response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on REST response content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/rest.md", + "start_line": 286, + "level": "MAY", + "text_digest": "440c8529d2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/rest.md", + "start_line": 293, + "level": "MAY", + "text_digest": "440c8529d2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0043", + "text_digest": "440c8529d2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "The response MAY include informational messages indicating which identifiers were not found.", + "normalized": "the response may include informational messages indicating which identifiers were not found", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 55, + "source": { + "file": "docs/specification/shopping/catalog/rest.md", + "start_line": 633, + "end_line": 634, + "section": "Catalog - REST Binding > Error Handling > Business Outcomes > Example: All Products Not Found", + "block_type": "paragraph", + "page": "specification/shopping/catalog/rest/", + "anchor": "example-all-products-not-found" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-REST-EXAMPLE-ALL-PRODUCTS-NOT-01", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: permission on REST response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on REST response content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/rest.md", + "start_line": 606, + "level": "MAY", + "text_digest": "440c8529d2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/rest.md", + "start_line": 636, + "level": "MAY", + "text_digest": "440c8529d2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0044", + "text_digest": "350f72606a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "A conforming REST transport implementation **MUST**:", + "normalized": "a conforming rest transport implementation must", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 61, + "source": { + "file": "docs/specification/shopping/catalog/rest.md", + "start_line": 685, + "end_line": 685, + "section": "Catalog - REST Binding > Conformance", + "block_type": "paragraph", + "page": "specification/shopping/catalog/rest/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-REST-CONFORMANCE-01", + "capability_source": "path (family)", + "keyword_style": "bold", + "transport": "rest", + "testable": false, + "testable_reason": "not a rule (reviewed): lead-in to a list; the obligations are the list items", + "review": { + "verdict": "not a rule", + "actor": "BUSINESS", + "testable": false, + "reason": "lead-in to a list; the obligations are the list items" + }, + "excluded": true, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/rest.md", + "start_line": 657, + "level": "MUST", + "text_digest": "350f72606a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/rest.md", + "start_line": 688, + "level": "MUST", + "text_digest": "350f72606a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0045", + "text_digest": "35a3e3f4dd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When the Lookup capability is advertised, both `/catalog/lookup` and `/catalog/product` MUST be available.", + "normalized": "when the lookup capability is advertised, both /catalog/lookup and /catalog/product must be available", + "condition": "When the Lookup capability is advertised", + "referenced_fields": [], + "compound_parent": "A conforming REST transport implementation **MUST**:", + "document_order": 64, + "source": { + "file": "docs/specification/shopping/catalog/rest.md", + "start_line": 687, + "end_line": 687, + "section": "Catalog - REST Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/catalog/rest/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-REST-CONFORMANCE-02", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: visible: both endpoints respond", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: both endpoints respond" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/rest.md", + "start_line": 659, + "level": "MUST", + "text_digest": "35a3e3f4dd" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/rest.md", + "start_line": 690, + "level": "MUST", + "text_digest": "35a3e3f4dd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-0046", + "text_digest": "f52390f942", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.lookup", + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Return HTTP 200 for lookup requests; unknown identifiers result in fewer products returned (MAY include informational `not_found` messages).", + "normalized": "return http 200 for lookup requests; unknown identifiers result in fewer products returned (may include informational not_found messages)", + "condition": null, + "referenced_fields": [ + "not_found" + ], + "compound_parent": "A conforming REST transport implementation **MUST**:", + "document_order": 67, + "source": { + "file": "docs/specification/shopping/catalog/rest.md", + "start_line": 691, + "end_line": 691, + "section": "Catalog - REST Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/catalog/rest/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-REST-CONFORMANCE-03", + "capability_source": "path (family)", + "keyword_style": "capitals", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: visible: HTTP 200 with fewer products", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: HTTP 200 with fewer products", + "level": "MUST", + "note": "the list's lead-in makes this a MUST; extracted as MAY" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/rest.md", + "start_line": 662, + "level": "MUST", + "text_digest": "f52390f942" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/rest.md", + "start_line": 694, + "level": "MUST", + "text_digest": "f52390f942" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/catalog/search.json b/requirements/catalog/shopping/catalog/search.json new file mode 100644 index 0000000..131f048 --- /dev/null +++ b/requirements/catalog/shopping/catalog/search.json @@ -0,0 +1,570 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/catalog/search.md", + "summary": { + "total": 10, + "must_count": 3, + "must_not_count": 1, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 1, + "should_not_count": 0, + "may_count": 5, + "by_level": { + "MAY": 5, + "MUST": 3, + "MUST NOT": 1, + "SHOULD": 1 + }, + "by_actor": { + "BUSINESS": 5, + "EXTENSION": 1, + "IMPLEMENTATION": 2, + "PLATFORM": 1, + "UNRESOLVED": 1 + }, + "by_file": { + "docs/specification/shopping/catalog/search.md": 10 + }, + "with_condition": 2, + "with_referenced_fields": 2, + "from_compound_split": 2, + "diagnostics": { + "actor_after_keyword_only": 1, + "actor_low_confidence": 0, + "actor_unresolved": 1, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 1, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0001", + "text_digest": "40c24b8fcb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "A valid search request MUST include at least one of: a `query` string, one or more `filters`, or an extension-defined input.", + "normalized": "a valid search request must include at least one of: a query string, one or more filters, or an extension-defined input", + "condition": null, + "referenced_fields": [ + "filters", + "query" + ], + "compound_parent": null, + "document_order": 8, + "source": { + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 40, + "end_line": 45, + "section": "Catalog Search Capability > Search Inputs", + "block_type": "paragraph", + "page": "specification/shopping/catalog/search/", + "anchor": "search-inputs" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-SEARCH-INPUTS-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: constrains the request", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "constrains the request" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/search.md", + "start_line": 40, + "level": "MUST", + "text_digest": "40c24b8fcb" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 40, + "level": "MUST", + "text_digest": "40c24b8fcb" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0002", + "text_digest": "00372ac58e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "EXTENSION", + "actor_confidence": 0.9, + "clause": "Extensions MAY define additional inputs (e.g., visual similarity, product references).", + "normalized": "extensions may define additional inputs (e.g., visual similarity, product references)", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 10, + "source": { + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 40, + "end_line": 45, + "section": "Catalog Search Capability > Search Inputs", + "block_type": "paragraph", + "page": "specification/shopping/catalog/search/", + "anchor": "search-inputs" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-SEARCH-INPUTS-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at extension authors", + "review": { + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "aimed at extension authors" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/search.md", + "start_line": 40, + "level": "MAY", + "text_digest": "00372ac58e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 40, + "level": "MAY", + "text_digest": "00372ac58e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0003", + "text_digest": "eb6fa97298", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "Implementations MUST validate that incoming requests contain at least one recognized input", + "normalized": "implementations must validate that incoming requests contain at least one recognized input", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 11, + "source": { + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 47, + "end_line": 51, + "section": "Catalog Search Capability > Search Inputs", + "block_type": "paragraph", + "page": "specification/shopping/catalog/search/", + "anchor": "search-inputs" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-SEARCH-INPUTS-03", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: an empty request is rejected", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: an empty request is rejected" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/search.md", + "start_line": 47, + "level": "MUST", + "text_digest": "eb6fa97298" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 47, + "level": "MUST", + "text_digest": "eb6fa97298" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0004", + "text_digest": "b25650806a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "SHOULD", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "Implementations SHOULD reject empty or invalid requests with an appropriate error.", + "normalized": "implementations should reject empty or invalid requests with an appropriate error", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 11, + "source": { + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 47, + "end_line": 51, + "section": "Catalog Search Capability > Search Inputs", + "block_type": "paragraph", + "page": "specification/shopping/catalog/search/", + "anchor": "search-inputs" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-SEARCH-INPUTS-04", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: an error for an empty or invalid request", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: an error for an empty or invalid request" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/search.md", + "start_line": 47, + "level": "SHOULD", + "text_digest": "b25650806a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 47, + "level": "SHOULD", + "text_digest": "b25650806a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0005", + "text_digest": "a4f12b4af8", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Standard filters are defined below; merchants MAY support additional custom filters via `additionalProperties`.", + "normalized": "standard filters are defined below; merchants may support additional custom filters via additionalproperties", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 14, + "source": { + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 55, + "end_line": 56, + "section": "Catalog Search Capability > Search Filters", + "block_type": "paragraph", + "page": "specification/shopping/catalog/search/", + "anchor": "search-filters" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-SEARCH-FILTERS-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; visible when used", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/catalog/search.md", + "start_line": 55, + "level": "MAY", + "text_digest": "a4f12b4af8" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 55, + "level": "MAY", + "text_digest": "a4f12b4af8" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0006", + "text_digest": "723735e908", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "A Business **MAY** encode them as stateless keyset tokens.", + "normalized": "a business may encode them as stateless keyset tokens", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 19, + "source": { + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 66, + "end_line": 67, + "section": "Catalog Search Capability > Pagination", + "block_type": "paragraph", + "page": "specification/shopping/catalog/search/", + "anchor": "pagination" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-PAGINATION-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 66, + "level": "MAY", + "text_digest": "723735e908" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0007", + "text_digest": "df9ab2c9da", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When `limit` is omitted, the Business **MUST** apply a default page size.", + "normalized": "when limit is omitted, the business must apply a default page size", + "condition": "When `limit` is omitted", + "referenced_fields": [ + "limit" + ], + "compound_parent": null, + "document_order": 21, + "source": { + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 71, + "end_line": 74, + "section": "Catalog Search Capability > Pagination > Page Size", + "block_type": "paragraph", + "page": "specification/shopping/catalog/search/", + "anchor": "page-size" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-PAGE-SIZE-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 71, + "level": "MUST", + "text_digest": "df9ab2c9da" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0008", + "text_digest": "92b975f598", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "A default of 10 is **RECOMMENDED**, but the Business **MAY** choose another value.", + "normalized": "a default of 10 is recommended, but the business may choose another value", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 22, + "source": { + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 71, + "end_line": 74, + "section": "Catalog Search Capability > Pagination > Page Size", + "block_type": "paragraph", + "page": "specification/shopping/catalog/search/", + "anchor": "page-size" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-PAGE-SIZE-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 71, + "level": "MAY", + "text_digest": "92b975f598" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0009", + "text_digest": "048b735954", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MAY** return fewer results than the requested or default page size, including when enforcing its maximum page size.", + "normalized": "the business may return fewer results than the requested or default page size, including when enforcing its maximum page size", + "condition": "when enforcing its maximum page size", + "referenced_fields": [], + "compound_parent": null, + "document_order": 23, + "source": { + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 76, + "end_line": 78, + "section": "Catalog Search Capability > Pagination > Page Size", + "block_type": "paragraph", + "page": "specification/shopping/catalog/search/", + "anchor": "page-size" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-PAGE-SIZE-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 76, + "level": "MAY", + "text_digest": "048b735954" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CATALOG-SEARCH-0010", + "text_digest": "5eb21c8c87", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.catalog.search" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "A Platform **MUST NOT** assume that the response count equals either value.", + "normalized": "a platform must not assume that the response count equals either value", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 24, + "source": { + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 76, + "end_line": 78, + "section": "Catalog Search Capability > Pagination > Page Size", + "block_type": "paragraph", + "page": "specification/shopping/catalog/search/", + "anchor": "page-size" + }, + "suite": { + "positional_id": "REQ-SHOPPING-CATALOG-SEARCH-SEARCH-PAGE-SIZE-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/catalog/search.md", + "start_line": 76, + "level": "MUST NOT", + "text_digest": "5eb21c8c87" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/checkout/a2a.json b/requirements/catalog/shopping/checkout/a2a.json new file mode 100644 index 0000000..a92a5f6 --- /dev/null +++ b/requirements/catalog/shopping/checkout/a2a.json @@ -0,0 +1,120 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/checkout/a2a.md", + "summary": { + "total": 1, + "must_count": 1, + "must_not_count": 0, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 0, + "should_not_count": 0, + "may_count": 0, + "by_level": { + "MUST": 1 + }, + "by_actor": { + "UNRESOLVED": 1 + }, + "by_file": { + "docs/specification/shopping/checkout/a2a.md": 1 + }, + "with_condition": 0, + "with_referenced_fields": 1, + "from_compound_split": 0, + "diagnostics": { + "actor_after_keyword_only": 0, + "actor_low_confidence": 0, + "actor_unresolved": 1, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 0, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CHECKOUT-0151", + "text_digest": "3fd4c0c210", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The checkout object **MUST** be returned as part of a `DataPart` object with key `a2a.ucp.checkout`.", + "normalized": "the checkout object must be returned as part of a datapart object with key a2a.ucp.checkout", + "condition": null, + "referenced_fields": [ + "a2a.ucp.checkout" + ], + "compound_parent": null, + "document_order": 31, + "source": { + "file": "docs/specification/shopping/checkout/a2a.md", + "start_line": 141, + "end_line": 147, + "section": "Checkout Capability - A2A Binding > Checkout Functionality", + "block_type": "paragraph", + "page": "specification/shopping/checkout/a2a/", + "anchor": "checkout-functionality" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-A2A-CHECKOUT-FUNCTIONALITY-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "a2a", + "testable": false, + "testable_reason": "A2A binding page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout-a2a.md", + "start_line": 138, + "level": "MUST", + "text_digest": "3fd4c0c210" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout-a2a.md", + "start_line": 139, + "level": "MUST", + "text_digest": "3fd4c0c210" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-a2a.md", + "start_line": 139, + "level": "MUST", + "text_digest": "3fd4c0c210" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/a2a.md", + "start_line": 141, + "level": "MUST", + "text_digest": "3fd4c0c210" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/checkout/embedded.json b/requirements/catalog/shopping/checkout/embedded.json new file mode 100644 index 0000000..f7c4b5a --- /dev/null +++ b/requirements/catalog/shopping/checkout/embedded.json @@ -0,0 +1,4773 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/checkout/embedded.md", + "summary": { + "total": 77, + "must_count": 44, + "must_not_count": 8, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 12, + "should_not_count": 1, + "may_count": 12, + "by_level": { + "MAY": 12, + "MUST": 44, + "MUST NOT": 8, + "SHOULD": 12, + "SHOULD NOT": 1 + }, + "by_actor": { + "BUSINESS": 8, + "EMBEDDED_CHECKOUT": 22, + "EXTENSION": 2, + "HOST": 32, + "IMPLEMENTATION": 1, + "UNRESOLVED": 12 + }, + "by_file": { + "docs/specification/shopping/checkout/embedded.md": 77 + }, + "with_condition": 22, + "with_referenced_fields": 38, + "from_compound_split": 6, + "diagnostics": { + "actor_after_keyword_only": 5, + "actor_low_confidence": 3, + "actor_unresolved": 12, + "annotation_as_obligation": 0, + "annotations_excluded": 18, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 3, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CHECKOUT-0152", + "text_digest": "d3a16bd983", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MUST** include an embedded service binding with `config.delegate` in checkout responses to indicate ECP availability and allowed delegations for a specific session.", + "normalized": "businesses must include an embedded service binding with config.delegate in checkout responses to indicate ecp availability and allowed delegations for a specific session", + "condition": null, + "referenced_fields": [ + "config.delegate" + ], + "compound_parent": null, + "document_order": 46, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 125, + "end_line": 128, + "section": "Checkout Capability - EP Binding > Requirements > Discovery > Per-Checkout Configuration", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "per-checkout-configuration" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-PER-CHECKOUT-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": true, + "testable_reason": "reviewed: visible in REST checkout responses; applies only to businesses that offer embedded checkout", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in REST checkout responses; applies only to businesses that offer embedded checkout" + }, + "since": "2026-01-23", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 124, + "level": "MUST", + "text_digest": "d3a16bd983" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 124, + "level": "MUST", + "text_digest": "d3a16bd983" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 125, + "level": "MUST", + "text_digest": "d3a16bd983" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0153", + "text_digest": "b9d5e402e6", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "When a host receives a checkout response with an embedded service binding, it **MAY** initiate an ECP session by loading the `continue_url` in an embedded context.", + "normalized": "when a host receives a checkout response with an embedded service binding, it may initiate an ecp session by loading the continue_url in an embedded context", + "condition": "When a host receives a checkout response with an embedded service binding", + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 61, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 177, + "end_line": 179, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "loading-an-embedded-checkout-url" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-LOADING-AN-EMBEDDED-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-23", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 175, + "level": "MAY", + "text_digest": "b9d5e402e6" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 175, + "level": "MAY", + "text_digest": "b9d5e402e6" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 177, + "level": "MAY", + "text_digest": "b9d5e402e6" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0154", + "text_digest": "40901b2bee", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "Before loading the embedded context, the host **SHOULD**:", + "normalized": "before loading the embedded context, the host should", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 62, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 181, + "end_line": 181, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "loading-an-embedded-checkout-url" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-LOADING-AN-EMBEDDED-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 122, + "level": "SHOULD", + "text_digest": "40901b2bee" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 179, + "level": "SHOULD", + "text_digest": "40901b2bee" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 179, + "level": "SHOULD", + "text_digest": "40901b2bee" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 181, + "level": "SHOULD", + "text_digest": "40901b2bee" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0155", + "text_digest": "3230757599", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "To initiate the session, the host **MUST** augment the `continue_url` with ECP query parameters using the `ec_` prefix.", + "normalized": "to initiate the session, the host must augment the continue_url with ecp query parameters using the ec_ prefix", + "condition": null, + "referenced_fields": [ + "continue_url", + "ec_" + ], + "compound_parent": null, + "document_order": 66, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 187, + "end_line": 188, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "loading-an-embedded-checkout-url" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-LOADING-AN-EMBEDDED-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 127, + "level": "MUST", + "text_digest": "3230757599" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 185, + "level": "MUST", + "text_digest": "3230757599" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 185, + "level": "MUST", + "text_digest": "3230757599" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 187, + "level": "MUST", + "text_digest": "3230757599" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0156", + "text_digest": "db1f71589a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.5, + "clause": "The version is negotiated at session initialization and **MUST** remain constant for the lifetime of the ECP session — neither party may change the version after the handshake.", + "normalized": "the version is negotiated at session initialization and must remain constant for the lifetime of the ecp session - neither party may change the version after the handshake", + "condition": null, + "referenced_fields": [], + "compound_parent": "All ECP parameters are passed via URL query string, not HTTP headers, to ensure maximum compatibility across different embedding environments. Parameters use the `ec_` prefix to avoid namespace pollution and clearly distinguish ECP parameters from business-specific query parameters:", + "document_order": 73, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 195, + "end_line": 199, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "loading-an-embedded-checkout-url" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-LOADING-AN-EMBEDDED-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 193, + "level": "MUST", + "text_digest": "db1f71589a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 195, + "level": "MUST", + "text_digest": "db1f71589a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0157", + "text_digest": "036cb43223", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.5, + "clause": "**SHOULD** be a subset of `config.delegate` from the embedded service binding.", + "normalized": "should be a subset of config.delegate from the embedded service binding", + "condition": null, + "referenced_fields": [ + "config.delegate" + ], + "compound_parent": "All ECP parameters are passed via URL query string, not HTTP headers, to ensure maximum compatibility across different embedding environments. Parameters use the `ec_` prefix to avoid namespace pollution and clearly distinguish ECP parameters from business-specific query parameters:", + "document_order": 78, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 202, + "end_line": 204, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "loading-an-embedded-checkout-url" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-LOADING-AN-EMBEDDED-05", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-23", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 197, + "level": "SHOULD", + "text_digest": "036cb43223" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 200, + "level": "SHOULD", + "text_digest": "036cb43223" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 202, + "level": "SHOULD", + "text_digest": "036cb43223" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0158", + "text_digest": "81afb6fb27", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MUST** document their expected token format and validation process", + "normalized": "businesses must document their expected token format and validation process", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Token Format:**", + "document_order": 87, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 215, + "end_line": 215, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL > Authentication", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "authentication" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-AUTHENTICATION-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "reviewed: documentation; not visible through the API", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "documentation; not visible through the API" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 148, + "level": "MUST", + "text_digest": "839daaba3c", + "clause": "Businesses **MUST** document their expected token format and validation process" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 207, + "level": "MUST", + "text_digest": "81afb6fb27" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 213, + "level": "MUST", + "text_digest": "81afb6fb27" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 215, + "level": "MUST", + "text_digest": "81afb6fb27" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0159", + "text_digest": "e5b5268361", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MUST** validate authentication according to their security requirements.", + "normalized": "businesses must validate authentication according to their security requirements", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 89, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 233, + "end_line": 234, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL > Authentication", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "authentication" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-AUTHENTICATION-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "reviewed: internal policy in the embedded flow", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "internal policy in the embedded flow" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 167, + "level": "MUST", + "text_digest": "e5b5268361" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 225, + "level": "MUST", + "text_digest": "e5b5268361" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 231, + "level": "MUST", + "text_digest": "e5b5268361" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 233, + "level": "MUST", + "text_digest": "e5b5268361" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0160", + "text_digest": "33e3f0b0e5", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "When `ec_color_scheme` is not provided, the Embedded Checkout can use the buyer's system preference via the [`prefers-color-scheme`](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme) media query or the [`Sec-CH-Prefers-Color-Scheme`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Sec-CH-Prefers-Color-Scheme) HTTP client hint, and **SHOULD** listen for changes and update accordingly.", + "normalized": "when ec_color_scheme is not provided, the embedded checkout can use the buyer's system preference via the prefers-color-scheme media query or the sec-ch-prefers-color-scheme http client hint, and should listen for changes and update accordingly", + "condition": "When `ec_color_scheme` is not provided", + "referenced_fields": [ + "ec_color_scheme" + ], + "compound_parent": null, + "document_order": 113, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 282, + "end_line": 287, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL > Color Scheme", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "color-scheme" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-COLOR-SCHEME-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 280, + "level": "SHOULD", + "text_digest": "33e3f0b0e5" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 282, + "level": "SHOULD", + "text_digest": "33e3f0b0e5" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0161", + "text_digest": "cbd466887a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "By default, the Embedded Checkout **SHOULD** respect the buyer's system color scheme preference and listen for changes to update accordingly", + "normalized": "by default, the embedded checkout should respect the buyer's system color scheme preference and listen for changes to update accordingly", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Implementation Notes:**", + "document_order": 115, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 291, + "end_line": 292, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL > Color Scheme", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "color-scheme" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-COLOR-SCHEME-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 289, + "level": "SHOULD", + "text_digest": "cbd466887a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 291, + "level": "SHOULD", + "text_digest": "cbd466887a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0162", + "text_digest": "830bc43945", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.5, + "clause": "When `ec_color_scheme` is explicitly provided, it **MUST** override the system preference, be applied immediately upon load, and be enforced for the duration of the session.", + "normalized": "when ec_color_scheme is explicitly provided, it must override the system preference, be applied immediately upon load, and be enforced for the duration of the session", + "condition": "When `ec_color_scheme` is explicitly provided", + "referenced_fields": [ + "ec_color_scheme" + ], + "compound_parent": "**Implementation Notes:**", + "document_order": 116, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 293, + "end_line": 295, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL > Color Scheme", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "color-scheme" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-COLOR-SCHEME-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 291, + "level": "MUST", + "text_digest": "830bc43945" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 293, + "level": "MUST", + "text_digest": "830bc43945" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0163", + "text_digest": "1e3b81573d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MAY** ignore unsupported values", + "normalized": "businesses may ignore unsupported values", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Implementation Notes:**", + "document_order": 117, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 296, + "end_line": 296, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL > Color Scheme", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "color-scheme" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-COLOR-SCHEME-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "reviewed: embedded checkout UI behavior", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "embedded checkout UI behavior" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 294, + "level": "MAY", + "text_digest": "1e3b81573d" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 296, + "level": "MAY", + "text_digest": "1e3b81573d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0164", + "text_digest": "cf58d72baa", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **SHOULD** only request delegations present in `config.delegate`", + "normalized": "the host should only request delegations present in config.delegate", + "condition": null, + "referenced_fields": [ + "config.delegate" + ], + "compound_parent": "Each stage is a subset of the previous:", + "document_order": 127, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 321, + "end_line": 321, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL > Delegation Negotiation", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "delegation-negotiation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-DELEGATION-NEGOTIATION-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-23", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 275, + "level": "SHOULD", + "text_digest": "cf58d72baa" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 319, + "level": "SHOULD", + "text_digest": "cf58d72baa" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 321, + "level": "SHOULD", + "text_digest": "cf58d72baa" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0165", + "text_digest": "2c534b146e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD NOT", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The business **SHOULD NOT** accept delegations not present in `config.delegate`", + "normalized": "the business should not accept delegations not present in config.delegate", + "condition": null, + "referenced_fields": [ + "config.delegate" + ], + "compound_parent": "Each stage is a subset of the previous:", + "document_order": 128, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 322, + "end_line": 323, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL > Delegation Negotiation", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "delegation-negotiation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-DELEGATION-NEGOTIATION-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "reviewed: embedded protocol negotiation, not REST", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "embedded protocol negotiation, not REST" + }, + "since": "2026-01-23", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 276, + "level": "SHOULD NOT", + "text_digest": "2c534b146e" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 320, + "level": "SHOULD NOT", + "text_digest": "2c534b146e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 322, + "level": "SHOULD NOT", + "text_digest": "2c534b146e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0166", + "text_digest": "bf3f2784f2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The business **MUST** confirm accepted delegations in `ec.ready`", + "normalized": "the business must confirm accepted delegations in ec.ready", + "condition": null, + "referenced_fields": [ + "ec.ready" + ], + "compound_parent": "Each stage is a subset of the previous:", + "document_order": 128, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 322, + "end_line": 323, + "section": "Checkout Capability - EP Binding > Requirements > Loading an Embedded Checkout URL > Delegation Negotiation", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "delegation-negotiation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-DELEGATION-NEGOTIATION-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "reviewed: embedded protocol message", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "embedded protocol message" + }, + "since": "2026-01-23", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 276, + "level": "MUST", + "text_digest": "bf3f2784f2" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 320, + "level": "MUST", + "text_digest": "bf3f2784f2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 322, + "level": "MUST", + "text_digest": "bf3f2784f2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0167", + "text_digest": "7c0f80c2dd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "However, the Embedded Checkout **MAY** restrict delegation to authenticated or approved hosts based on business policy.", + "normalized": "however, the embedded checkout may restrict delegation to authenticated or approved hosts based on business policy", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 130, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 327, + "end_line": 329, + "section": "Checkout Capability - EP Binding > Requirements > Delegation Contract", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "delegation-contract" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-DELEGATION-CONTRACT-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 202, + "level": "MAY", + "text_digest": "7c0f80c2dd" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 281, + "level": "MAY", + "text_digest": "7c0f80c2dd" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 325, + "level": "MAY", + "text_digest": "7c0f80c2dd" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 327, + "level": "MAY", + "text_digest": "7c0f80c2dd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0168", + "text_digest": "a7063be24b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "The Embedded Checkout **MUST** indicate accepted delegations in the `ec.ready` request via the `delegate` field (see [`ec.ready`](#ecready)).", + "normalized": "the embedded checkout must indicate accepted delegations in the ec.ready request via the delegate field (see ec.ready)", + "condition": null, + "referenced_fields": [ + "delegate", + "ec.ready" + ], + "compound_parent": null, + "document_order": 135, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 339, + "end_line": 342, + "section": "Checkout Capability - EP Binding > Requirements > Delegation Contract > Delegation Acceptance", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "delegation-acceptance" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-DELEGATION-ACCEPTANCE-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 214, + "level": "MUST", + "text_digest": "a7063be24b" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 293, + "level": "MUST", + "text_digest": "a7063be24b" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 337, + "level": "MUST", + "text_digest": "a7063be24b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 339, + "level": "MUST", + "text_digest": "a7063be24b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0169", + "text_digest": "71b19fcb62", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "If a requested delegation is not accepted, the Embedded Checkout **MUST** handle that action using its own UI.", + "normalized": "if a requested delegation is not accepted, the embedded checkout must handle that action using its own ui", + "condition": "If a requested delegation is not accepted", + "referenced_fields": [], + "compound_parent": null, + "document_order": 136, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 339, + "end_line": 342, + "section": "Checkout Capability - EP Binding > Requirements > Delegation Contract > Delegation Acceptance", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "delegation-acceptance" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-DELEGATION-ACCEPTANCE-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 214, + "level": "MUST", + "text_digest": "bb20885011", + "clause": "If a requested delegation is not accepted, the Embedded Checkout **MUST** handle that capability using its own UI." + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 293, + "level": "MUST", + "text_digest": "bb20885011", + "clause": "If a requested delegation is not accepted, the Embedded Checkout **MUST** handle that capability using its own UI." + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 337, + "level": "MUST", + "text_digest": "71b19fcb62" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 339, + "level": "MUST", + "text_digest": "71b19fcb62" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0170", + "text_digest": "b24866bb8b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.8, + "clause": "**MUST** fire the appropriate `{action}_request` message when that action is triggered", + "normalized": "must fire the appropriate {action}_request message when that action is triggered", + "condition": "when that action is triggered", + "referenced_fields": [], + "compound_parent": "**Embedded Checkout responsibilities:**", + "document_order": 139, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 350, + "end_line": 351, + "section": "Checkout Capability - EP Binding > Requirements > Delegation Contract > Binding Requirements", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "binding-requirements" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-BINDING-REQUIREMENTS-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 225, + "level": "MUST", + "text_digest": "a669b3acaa", + "clause": "**MUST** fire the appropriate `{action}_request` message when that action is triggered" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 304, + "level": "MUST", + "text_digest": "b24866bb8b" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 348, + "level": "MUST", + "text_digest": "b24866bb8b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 350, + "level": "MUST", + "text_digest": "b24866bb8b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0171", + "text_digest": "b33f69b0a1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.8, + "clause": "**MUST** wait for the host's response before proceeding", + "normalized": "must wait for the host's response before proceeding", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Embedded Checkout responsibilities:**", + "document_order": 140, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 352, + "end_line": 352, + "section": "Checkout Capability - EP Binding > Requirements > Delegation Contract > Binding Requirements", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "binding-requirements" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-BINDING-REQUIREMENTS-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 227, + "level": "MUST", + "text_digest": "2bb80500b4", + "clause": "**MUST** wait for the host's response before proceeding" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 306, + "level": "MUST", + "text_digest": "b33f69b0a1" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 350, + "level": "MUST", + "text_digest": "b33f69b0a1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 352, + "level": "MUST", + "text_digest": "b33f69b0a1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0172", + "text_digest": "12912430f0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.8, + "clause": "**MUST NOT** show its own UI for that delegated action", + "normalized": "must not show its own ui for that delegated action", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Embedded Checkout responsibilities:**", + "document_order": 141, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 353, + "end_line": 353, + "section": "Checkout Capability - EP Binding > Requirements > Delegation Contract > Binding Requirements", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "binding-requirements" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-BINDING-REQUIREMENTS-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 228, + "level": "MUST NOT", + "text_digest": "f835209480", + "clause": "**MUST NOT** show its own UI for that delegated action" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 307, + "level": "MUST NOT", + "text_digest": "12912430f0" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 351, + "level": "MUST NOT", + "text_digest": "12912430f0" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 353, + "level": "MUST NOT", + "text_digest": "12912430f0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0173", + "text_digest": "623e486ff4", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.8, + "clause": "**MUST** respond to every `{action}_request` message it receives", + "normalized": "must respond to every {action}_request message it receives", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Host responsibilities:**", + "document_order": 143, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 357, + "end_line": 357, + "section": "Checkout Capability - EP Binding > Requirements > Delegation Contract > Binding Requirements", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "binding-requirements" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-BINDING-REQUIREMENTS-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 232, + "level": "MUST", + "text_digest": "360fe2def1", + "clause": "**MUST** respond to every `{action}_request` message it receives" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 311, + "level": "MUST", + "text_digest": "623e486ff4" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 355, + "level": "MUST", + "text_digest": "623e486ff4" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 357, + "level": "MUST", + "text_digest": "623e486ff4" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0174", + "text_digest": "ef9672232b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.8, + "clause": "**MUST** respond with an appropriate error if the user cancels", + "normalized": "must respond with an appropriate error if the user cancels", + "condition": "if the user cancels", + "referenced_fields": [], + "compound_parent": "**Host responsibilities:**", + "document_order": 144, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 358, + "end_line": 358, + "section": "Checkout Capability - EP Binding > Requirements > Delegation Contract > Binding Requirements", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "binding-requirements" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-BINDING-REQUIREMENTS-05", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 233, + "level": "MUST", + "text_digest": "bbf4019dfe", + "clause": "**MUST** respond with an appropriate error if the user cancels" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 312, + "level": "MUST", + "text_digest": "ef9672232b" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 356, + "level": "MUST", + "text_digest": "ef9672232b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 358, + "level": "MUST", + "text_digest": "ef9672232b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0175", + "text_digest": "d709c5a4ac", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "HOST", + "actor_confidence": 0.8, + "clause": "**SHOULD** show loading/processing states while handling delegation", + "normalized": "should show loading/processing states while handling delegation", + "condition": "while handling delegation", + "referenced_fields": [], + "compound_parent": "**Host responsibilities:**", + "document_order": 145, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 359, + "end_line": 359, + "section": "Checkout Capability - EP Binding > Requirements > Delegation Contract > Binding Requirements", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "binding-requirements" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-BINDING-REQUIREMENTS-06", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 234, + "level": "SHOULD", + "text_digest": "a5596dbc90", + "clause": "**SHOULD** show loading/processing states while handling delegation" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 313, + "level": "SHOULD", + "text_digest": "d709c5a4ac" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 357, + "level": "SHOULD", + "text_digest": "d709c5a4ac" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 359, + "level": "SHOULD", + "text_digest": "d709c5a4ac" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0176", + "text_digest": "9af2ffa86a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "When checkout is rendered in embedded mode, the implementation **SHOULD** prevent off-checkout navigation to maintain a focused checkout experience.", + "normalized": "when checkout is rendered in embedded mode, the implementation should prevent off-checkout navigation to maintain a focused checkout experience", + "condition": "When checkout is rendered in embedded mode", + "referenced_fields": [], + "compound_parent": null, + "document_order": 154, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 378, + "end_line": 381, + "section": "Checkout Capability - EP Binding > Requirements > Navigation Constraints", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "navigation-constraints" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-NAVIGATION-CONSTRAINTS-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 252, + "level": "SHOULD", + "text_digest": "9af2ffa86a" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 331, + "level": "SHOULD", + "text_digest": "9af2ffa86a" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 376, + "level": "SHOULD", + "text_digest": "9af2ffa86a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 378, + "level": "SHOULD", + "text_digest": "9af2ffa86a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0177", + "text_digest": "064ee17546", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "The embedded checkout **SHOULD** block or intercept navigation attempts to URLs outside the checkout flow", + "normalized": "the embedded checkout should block or intercept navigation attempts to urls outside the checkout flow", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Navigation Requirements:**", + "document_order": 157, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 385, + "end_line": 386, + "section": "Checkout Capability - EP Binding > Requirements > Navigation Constraints", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "navigation-constraints" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-NAVIGATION-CONSTRAINTS-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 259, + "level": "SHOULD", + "text_digest": "524f2330ab", + "clause": "The embedded checkout **SHOULD** block or intercept navigation attempts to URLs outside the checkout flow" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 338, + "level": "SHOULD", + "text_digest": "064ee17546" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 383, + "level": "SHOULD", + "text_digest": "064ee17546" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 385, + "level": "SHOULD", + "text_digest": "064ee17546" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0178", + "text_digest": "eea24f25f2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "The embedded checkout **SHOULD** remove or disable UI elements that would navigate away from checkout (e.g., external links, navigation bars)", + "normalized": "the embedded checkout should remove or disable ui elements that would navigate away from checkout (e.g., external links, navigation bars)", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Navigation Requirements:**", + "document_order": 158, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 387, + "end_line": 388, + "section": "Checkout Capability - EP Binding > Requirements > Navigation Constraints", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "navigation-constraints" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-NAVIGATION-CONSTRAINTS-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 261, + "level": "SHOULD", + "text_digest": "da73d17c08", + "clause": "The embedded checkout **SHOULD** remove or disable UI elements that would navigate away from checkout (e.g., external links, navigation bars)" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 340, + "level": "SHOULD", + "text_digest": "eea24f25f2" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 385, + "level": "SHOULD", + "text_digest": "eea24f25f2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 387, + "level": "SHOULD", + "text_digest": "eea24f25f2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0179", + "text_digest": "258443814e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The embedder **MAY** implement additional navigation restrictions at the container level", + "normalized": "the embedder may implement additional navigation restrictions at the container level", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Navigation Requirements:**", + "document_order": 159, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 389, + "end_line": 390, + "section": "Checkout Capability - EP Binding > Requirements > Navigation Constraints", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "navigation-constraints" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-NAVIGATION-CONSTRAINTS-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 263, + "level": "MAY", + "text_digest": "63b0f768b1", + "clause": "The embedder **MAY** implement additional navigation restrictions at the container level" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 342, + "level": "MAY", + "text_digest": "258443814e" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 387, + "level": "MAY", + "text_digest": "258443814e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 389, + "level": "MAY", + "text_digest": "258443814e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0180", + "text_digest": "35d3489e9b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**Permitted Exceptions:** The following navigation scenarios **MAY** be allowed when required for checkout completion:", + "normalized": "permitted exceptions: the following navigation scenarios may be allowed when required for checkout completion", + "condition": "when required for checkout completion", + "referenced_fields": [], + "compound_parent": null, + "document_order": 160, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 392, + "end_line": 393, + "section": "Checkout Capability - EP Binding > Requirements > Navigation Constraints", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "navigation-constraints" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-NAVIGATION-CONSTRAINTS-05", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 266, + "level": "MAY", + "text_digest": "35d3489e9b" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 345, + "level": "MAY", + "text_digest": "35d3489e9b" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 390, + "level": "MAY", + "text_digest": "35d3489e9b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 392, + "level": "MAY", + "text_digest": "35d3489e9b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0181", + "text_digest": "1df2a4b4f1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "These exceptions **SHOULD** return the user to the checkout flow upon completion.", + "normalized": "these exceptions should return the user to the checkout flow upon completion", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 166, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 400, + "end_line": 401, + "section": "Checkout Capability - EP Binding > Requirements > Navigation Constraints", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "navigation-constraints" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-NAVIGATION-CONSTRAINTS-06", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 274, + "level": "SHOULD", + "text_digest": "1df2a4b4f1" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 353, + "level": "SHOULD", + "text_digest": "1df2a4b4f1" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 398, + "level": "SHOULD", + "text_digest": "1df2a4b4f1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 400, + "level": "SHOULD", + "text_digest": "1df2a4b4f1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0182", + "text_digest": "d27d8e1378", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The `ucp.version` in all responses **MUST** echo the `ec_version` negotiated during session initialization and confirmed by the host in the `ec.ready` response.", + "normalized": "the ucp.version in all responses must echo the ec_version negotiated during session initialization and confirmed by the host in the ec.ready response", + "condition": null, + "referenced_fields": [ + "ec.ready", + "ec_version", + "ucp.version" + ], + "compound_parent": null, + "document_order": 169, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 409, + "end_line": 412, + "section": "Checkout Capability - EP Binding > Transport & Messaging", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "transport-messaging" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-TRANSPORT-MESSAGING-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 407, + "level": "MUST", + "text_digest": "d27d8e1378" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 409, + "level": "MUST", + "text_digest": "d27d8e1378" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0183", + "text_digest": "e31c7d39c1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The version is session-bound — it **MUST NOT** change for the duration of the ECP session.", + "normalized": "the version is session-bound - it must not change for the duration of the ecp session", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 170, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 409, + "end_line": 412, + "section": "Checkout Capability - EP Binding > Transport & Messaging", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "transport-messaging" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-TRANSPORT-MESSAGING-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 407, + "level": "MUST NOT", + "text_digest": "e31c7d39c1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 409, + "level": "MUST NOT", + "text_digest": "e31c7d39c1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0184", + "text_digest": "629595ef1a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Core messages are defined by the ECP specification and **MUST** be supported by all implementations.", + "normalized": "core messages are defined by the ecp specification and must be supported by all implementations", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 177, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 432, + "end_line": 433, + "section": "Checkout Capability - EP Binding > Message API Reference > Message Categories > Core Messages", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "core-messages" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-CORE-MESSAGES-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 372, + "level": "MUST", + "text_digest": "629595ef1a" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 450, + "level": "MUST", + "text_digest": "629595ef1a" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 430, + "level": "MUST", + "text_digest": "629595ef1a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 432, + "level": "MUST", + "text_digest": "629595ef1a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0185", + "text_digest": "49e984cded", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "EXTENSION", + "actor_confidence": 0.9, + "clause": "Extensions **MAY** extend the Embedded protocol by defining additional messages.", + "normalized": "extensions may extend the embedded protocol by defining additional messages", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 199, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 445, + "end_line": 446, + "section": "Checkout Capability - EP Binding > Message API Reference > Message Categories > Extension Messages", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "extension-messages" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EXTENSION-MESSAGES-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 383, + "level": "MAY", + "text_digest": "49e984cded" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 461, + "level": "MAY", + "text_digest": "49e984cded" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 443, + "level": "MAY", + "text_digest": "49e984cded" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 445, + "level": "MAY", + "text_digest": "49e984cded" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0186", + "text_digest": "6610687fbf", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EXTENSION", + "actor_confidence": 0.9, + "clause": "Extension messages **MUST** follow the naming convention:", + "normalized": "extension messages must follow the naming convention", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 200, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 445, + "end_line": 446, + "section": "Checkout Capability - EP Binding > Message API Reference > Message Categories > Extension Messages", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "extension-messages" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EXTENSION-MESSAGES-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 383, + "level": "MUST", + "text_digest": "6610687fbf" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 461, + "level": "MUST", + "text_digest": "6610687fbf" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 443, + "level": "MUST", + "text_digest": "6610687fbf" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 445, + "level": "MUST", + "text_digest": "6610687fbf" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0187", + "text_digest": "a3d2f4d56f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "Upon rendering, the Embedded Checkout **MUST** broadcast readiness to the parent context using the `ec.ready` message.", + "normalized": "upon rendering, the embedded checkout must broadcast readiness to the parent context using the ec.ready message", + "condition": null, + "referenced_fields": [ + "ec.ready" + ], + "compound_parent": null, + "document_order": 209, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 465, + "end_line": 470, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 402, + "level": "MUST", + "text_digest": "a3d2f4d56f" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 480, + "level": "MUST", + "text_digest": "a3d2f4d56f" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 463, + "level": "MUST", + "text_digest": "a3d2f4d56f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 465, + "level": "MUST", + "text_digest": "a3d2f4d56f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0188", + "text_digest": "5983dfa675", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** be a subset of both `ec_delegate` (what host requested) and `config.delegate` from the checkout response (what business allows).", + "normalized": "must be a subset of both ec_delegate (what host requested) and config.delegate from the checkout response (what business allows)", + "condition": null, + "referenced_fields": [ + "config.delegate", + "ec_delegate" + ], + "compound_parent": "**Payload:**", + "document_order": 216, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 475, + "end_line": 479, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-23", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 490, + "level": "MUST", + "text_digest": "5983dfa675" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 473, + "level": "MUST", + "text_digest": "5983dfa675" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 475, + "level": "MUST", + "text_digest": "5983dfa675" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0189", + "text_digest": "66c2becef2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The `ec.ready` message is a request, which means that the host **MUST** respond to complete the handshake.", + "normalized": "the ec.ready message is a request, which means that the host must respond to complete the handshake", + "condition": null, + "referenced_fields": [ + "ec.ready" + ], + "compound_parent": null, + "document_order": 223, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 520, + "end_line": 521, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 443, + "level": "MUST", + "text_digest": "66c2becef2" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 522, + "level": "MUST", + "text_digest": "66c2becef2" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 516, + "level": "MUST", + "text_digest": "66c2becef2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 520, + "level": "MUST", + "text_digest": "66c2becef2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0190", + "text_digest": "2e7656caf9", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The `version` confirms the negotiated `ec_version` and `status` **MUST** be `\"success\"`.", + "normalized": "the version confirms the negotiated ec_version and status must be \"success\"", + "condition": null, + "referenced_fields": [ + "ec_version", + "status", + "version" + ], + "compound_parent": "**Result Payload:**", + "document_order": 229, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 526, + "end_line": 530, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 522, + "level": "MUST", + "text_digest": "2e7656caf9" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 526, + "level": "MUST", + "text_digest": "2e7656caf9" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0191", + "text_digest": "d4a5ed6089", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "This version is session-bound — the host explicitly confirms the protocol version here, and it **MUST NOT** change for the duration of the session.", + "normalized": "this version is session-bound - the host explicitly confirms the protocol version here, and it must not change for the duration of the session", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Result Payload:**", + "document_order": 230, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 526, + "end_line": 530, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-05", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 522, + "level": "MUST NOT", + "text_digest": "d4a5ed6089" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 526, + "level": "MUST NOT", + "text_digest": "d4a5ed6089" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0192", + "text_digest": "5e3413cd0d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "When present, host **MUST NOT** include `credential` — the channel will be re-established and any credential sent here will be discarded.", + "normalized": "when present, host must not include credential - the channel will be re-established and any credential sent here will be discarded", + "condition": "When present", + "referenced_fields": [ + "credential" + ], + "compound_parent": "**Result Payload:**", + "document_order": 233, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 531, + "end_line": 535, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-06", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 527, + "level": "MUST NOT", + "text_digest": "5e3413cd0d" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 531, + "level": "MUST NOT", + "text_digest": "5e3413cd0d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0193", + "text_digest": "abdc68d4ce", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The requested authorization data, can be in the form of an OAuth token, JWT, API keys, etc. **MUST** be set if `auth` is present in the request.", + "normalized": "the requested authorization data, can be in the form of an oauth token, jwt, api keys, etc. must be set if auth is present in the request", + "condition": "if `auth` is present in the request", + "referenced_fields": [ + "auth" + ], + "compound_parent": "**Result Payload:**", + "document_order": 235, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 536, + "end_line": 539, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-07", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 532, + "level": "MUST", + "text_digest": "abdc68d4ce" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 536, + "level": "MUST", + "text_digest": "abdc68d4ce" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0194", + "text_digest": "8c8a34c733", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST NOT** be set if `upgrade` is present.", + "normalized": "must not be set if upgrade is present", + "condition": "if `upgrade` is present", + "referenced_fields": [ + "upgrade" + ], + "compound_parent": "**Result Payload:**", + "document_order": 236, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 536, + "end_line": 539, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-08", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 532, + "level": "MUST NOT", + "text_digest": "8c8a34c733" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 536, + "level": "MUST NOT", + "text_digest": "8c8a34c733" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0195", + "text_digest": "d761ce51d7", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "Hosts **MAY** respond with an `upgrade` field to update the communication channel between host and Embedded Checkout.", + "normalized": "hosts may respond with an upgrade field to update the communication channel between host and embedded checkout", + "condition": null, + "referenced_fields": [ + "upgrade" + ], + "compound_parent": null, + "document_order": 242, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 561, + "end_line": 565, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-09", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 469, + "level": "MAY", + "text_digest": "d761ce51d7" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 548, + "level": "MAY", + "text_digest": "d761ce51d7" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 556, + "level": "MAY", + "text_digest": "d761ce51d7" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 561, + "level": "MAY", + "text_digest": "d761ce51d7" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0196", + "text_digest": "eb3704265c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Currently, this object only supports a `port` field, which **MUST** be a `MessagePort` object", + "normalized": "currently, this object only supports a port field, which must be a messageport object", + "condition": null, + "referenced_fields": [ + "port" + ], + "compound_parent": null, + "document_order": 243, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 561, + "end_line": 565, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-10", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 469, + "level": "MUST", + "text_digest": "eb3704265c" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 548, + "level": "MUST", + "text_digest": "eb3704265c" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 556, + "level": "MUST", + "text_digest": "eb3704265c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 561, + "level": "MUST", + "text_digest": "eb3704265c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0197", + "text_digest": "9dbc2de6b2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Currently, this object only supports a `port` field, which **MUST** be transferred to the embedded checkout context (e.g., with `{transfer: [port2]}` on the host's `iframe.contentWindow.postMessage()` call)", + "normalized": "currently, this object only supports a port field, which must be transferred to the embedded checkout context (e.g., with {transfer: [port2]} on the host's iframe.contentwindow.postmessage() call)", + "condition": null, + "referenced_fields": [ + "port" + ], + "compound_parent": null, + "document_order": 243, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 561, + "end_line": 565, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-11", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 469, + "level": "MUST", + "text_digest": "9dbc2de6b2" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 548, + "level": "MUST", + "text_digest": "9dbc2de6b2" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 556, + "level": "MUST", + "text_digest": "9dbc2de6b2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 561, + "level": "MUST", + "text_digest": "9dbc2de6b2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0198", + "text_digest": "7604d830f0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "When the host responds with an `upgrade` object, the Embedded Checkout **MUST** discard any other information in the message, send a new `ec.ready` message over the upgraded communication channel, and wait for a new response.", + "normalized": "when the host responds with an upgrade object, the embedded checkout must discard any other information in the message, send a new ec.ready message over the upgraded communication channel, and wait for a new response", + "condition": "When the host responds with an `upgrade` object", + "referenced_fields": [ + "ec.ready", + "upgrade" + ], + "compound_parent": null, + "document_order": 245, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 583, + "end_line": 587, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-12", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 489, + "level": "MUST", + "text_digest": "7604d830f0" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 568, + "level": "MUST", + "text_digest": "7604d830f0" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 577, + "level": "MUST", + "text_digest": "7604d830f0" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 583, + "level": "MUST", + "text_digest": "7604d830f0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0199", + "text_digest": "a809664137", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "All subsequent messages **MUST** be sent only over the upgraded communication channel.", + "normalized": "all subsequent messages must be sent only over the upgraded communication channel", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 246, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 583, + "end_line": 587, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-13", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 489, + "level": "MUST", + "text_digest": "a809664137" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 568, + "level": "MUST", + "text_digest": "a809664137" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 577, + "level": "MUST", + "text_digest": "a809664137" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 583, + "level": "MUST", + "text_digest": "a809664137" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0200", + "text_digest": "273736b04d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **MAY** also respond with a `checkout` object, which will be used to populate the checkout UI according to the delegation contract between host and business.", + "normalized": "the host may also respond with a checkout object, which will be used to populate the checkout ui according to the delegation contract between host and business", + "condition": null, + "referenced_fields": [ + "checkout" + ], + "compound_parent": null, + "document_order": 247, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 589, + "end_line": 591, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-14", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 494, + "level": "MAY", + "text_digest": "273736b04d" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 574, + "level": "MAY", + "text_digest": "273736b04d" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 583, + "level": "MAY", + "text_digest": "273736b04d" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 589, + "level": "MAY", + "text_digest": "273736b04d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0201", + "text_digest": "b4ddfaed6e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "If the host cannot complete the handshake (e.g., origin validation failure or protocol state violation), it **MUST** respond with an `error_response` result:", + "normalized": "if the host cannot complete the handshake (e.g., origin validation failure or protocol state violation), it must respond with an error_response result", + "condition": "If the host cannot complete the handshake (e.g., origin validation failure or protocol state violation)", + "referenced_fields": [ + "error_response" + ], + "compound_parent": null, + "document_order": 251, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 630, + "end_line": 631, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-15", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 623, + "level": "MUST", + "text_digest": "b4ddfaed6e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 630, + "level": "MUST", + "text_digest": "b4ddfaed6e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0202", + "text_digest": "dfcef5c6f2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **MUST** tear down the embedded context", + "normalized": "the host must tear down the embedded context", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 253, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 652, + "end_line": 655, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-16", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 644, + "level": "MUST", + "text_digest": "dfcef5c6f2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 652, + "level": "MUST", + "text_digest": "dfcef5c6f2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0203", + "text_digest": "c45fb9f3f1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **MAY** redirect the buyer to `continue_url` if present.", + "normalized": "the host may redirect the buyer to continue_url if present", + "condition": "if present", + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 253, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 652, + "end_line": 655, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-17", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 644, + "level": "MAY", + "text_digest": "c45fb9f3f1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 652, + "level": "MAY", + "text_digest": "c45fb9f3f1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0204", + "text_digest": "0c350741c8", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "The Embedded Checkout **MUST NOT** send further messages after receiving a handshake error.", + "normalized": "the embedded checkout must not send further messages after receiving a handshake error", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 254, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 652, + "end_line": 655, + "section": "Checkout Capability - EP Binding > Message API Reference > Handshake Messages > `ec.ready`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecready" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-READY-18", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 644, + "level": "MUST NOT", + "text_digest": "0c350741c8" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 652, + "level": "MUST NOT", + "text_digest": "0c350741c8" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0205", + "text_digest": "a49ddfe7c1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "When error escalation is required, Embedded Checkout **MUST** issue an `ec.error` notification per the [session error pattern](../../embedded-protocol.md#session-error).", + "normalized": "when error escalation is required, embedded checkout must issue an ec.error notification per the session error pattern", + "condition": "When error escalation is required", + "referenced_fields": [ + "ec.error" + ], + "compound_parent": null, + "document_order": 259, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 668, + "end_line": 670, + "section": "Checkout Capability - EP Binding > Message API Reference > Authentication > `ec.auth`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecauth" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-AUTH-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 660, + "level": "MUST", + "text_digest": "a49ddfe7c1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 668, + "level": "MUST", + "text_digest": "a49ddfe7c1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0206", + "text_digest": "99e001b8a5", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MUST** send this message whenever `checkout.totals` changes for any reason.", + "normalized": "businesses must send this message whenever checkout.totals changes for any reason", + "condition": "whenever `checkout.totals` changes for any reason", + "referenced_fields": [ + "checkout.totals" + ], + "compound_parent": null, + "document_order": 303, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 852, + "end_line": 855, + "section": "Checkout Capability - EP Binding > Message API Reference > State Change Messages > `ec.totals.change`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ectotalschange" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-TOTALS-CHANGE-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "reviewed: embedded protocol message", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "embedded protocol message" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 845, + "level": "MUST", + "text_digest": "99e001b8a5" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 852, + "level": "MUST", + "text_digest": "99e001b8a5" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0207", + "text_digest": "5023f77e0f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When a change also triggers a domain-specific message (e.g., `ec.line_items.change`, `ec.buyer.change`, or `ec.payment.change`), the business **MUST** send the domain-specific message first, then follow it with `ec.totals.change`.", + "normalized": "when a change also triggers a domain-specific message (e.g., ec.line_items.change, ec.buyer.change, or ec.payment.change), the business must send the domain-specific message first, then follow it with ec.totals.change", + "condition": "When a change also triggers a domain-specific message (e.g., `ec.line_items.change`, `ec.buyer.change`, or `ec.payment.change`)", + "referenced_fields": [ + "ec.buyer.change", + "ec.line_items.change", + "ec.payment.change", + "ec.totals.change" + ], + "compound_parent": null, + "document_order": 304, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 857, + "end_line": 860, + "section": "Checkout Capability - EP Binding > Message API Reference > State Change Messages > `ec.totals.change`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ectotalschange" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-TOTALS-CHANGE-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "reviewed: embedded protocol message", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "embedded protocol message" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 850, + "level": "MUST", + "text_digest": "5023f77e0f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 857, + "level": "MUST", + "text_digest": "5023f77e0f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0208", + "text_digest": "2f8c3a174a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **MUST** respond with either an error, or the newly-selected payment instruments.", + "normalized": "the host must respond with either an error, or the newly-selected payment instruments", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 349, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1026, + "end_line": 1031, + "section": "Checkout Capability - EP Binding > Payment Extension > Payment Message API Reference > `ec.payment.instruments_change_request`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecpaymentinstruments_change_request" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-PAYMENT-INSTRUMENTS-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 819, + "level": "MUST", + "text_digest": "2f8c3a174a" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 892, + "level": "MUST", + "text_digest": "2f8c3a174a" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1018, + "level": "MUST", + "text_digest": "2f8c3a174a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1026, + "level": "MUST", + "text_digest": "2f8c3a174a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0209", + "text_digest": "f8653b81c3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "In successful responses, the host **MUST** respond with a partial update to the `checkout` object, with only the `payment.instruments` field updated.", + "normalized": "in successful responses, the host must respond with a partial update to the checkout object, with only the payment.instruments field updated", + "condition": null, + "referenced_fields": [ + "checkout", + "payment.instruments" + ], + "compound_parent": null, + "document_order": 350, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1026, + "end_line": 1031, + "section": "Checkout Capability - EP Binding > Payment Extension > Payment Message API Reference > `ec.payment.instruments_change_request`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecpaymentinstruments_change_request" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-PAYMENT-INSTRUMENTS-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 819, + "level": "MUST", + "text_digest": "749fc22145", + "clause": "In successful responses, the host **MUST** respond with a partial update to the `checkout` object, with only the `payment.instruments` and `payment.selected_instrument_id` fields updated." + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 892, + "level": "MUST", + "text_digest": "f8653b81c3" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1018, + "level": "MUST", + "text_digest": "f8653b81c3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1026, + "level": "MUST", + "text_digest": "f8653b81c3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0210", + "text_digest": "e0c6543fed", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "The Embedded Checkout **MUST** treat this update as a PUT-style change by entirely replacing the existing state for the provided fields, rather than attempting to merge the new data with existing state.", + "normalized": "the embedded checkout must treat this update as a put-style change by entirely replacing the existing state for the provided fields, rather than attempting to merge the new data with existing state", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 351, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1026, + "end_line": 1031, + "section": "Checkout Capability - EP Binding > Payment Extension > Payment Message API Reference > `ec.payment.instruments_change_request`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecpaymentinstruments_change_request" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-PAYMENT-INSTRUMENTS-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 819, + "level": "MUST", + "text_digest": "e0c6543fed" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 892, + "level": "MUST", + "text_digest": "e0c6543fed" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1018, + "level": "MUST", + "text_digest": "e0c6543fed" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1026, + "level": "MUST", + "text_digest": "e0c6543fed" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0211", + "text_digest": "0d386b4856", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **MUST** respond with either an error, or the credential for the selected payment instrument.", + "normalized": "the host must respond with either an error, or the credential for the selected payment instrument", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 368, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1132, + "end_line": 1138, + "section": "Checkout Capability - EP Binding > Payment Extension > Payment Message API Reference > `ec.payment.credential_request`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecpaymentcredential_request" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-PAYMENT-CREDENTIAL-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 912, + "level": "MUST", + "text_digest": "0d386b4856" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 986, + "level": "MUST", + "text_digest": "0d386b4856" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1121, + "level": "MUST", + "text_digest": "0d386b4856" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1132, + "level": "MUST", + "text_digest": "0d386b4856" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0212", + "text_digest": "22353ff600", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "In successful responses, the host **MUST** supply a partial update to the `checkout` object, updating the instrument with `selected: true` with the new `credentials` field.", + "normalized": "in successful responses, the host must supply a partial update to the checkout object, updating the instrument with selected: true with the new credentials field", + "condition": null, + "referenced_fields": [ + "checkout", + "credentials", + "selected" + ], + "compound_parent": null, + "document_order": 369, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1132, + "end_line": 1138, + "section": "Checkout Capability - EP Binding > Payment Extension > Payment Message API Reference > `ec.payment.credential_request`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecpaymentcredential_request" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-PAYMENT-CREDENTIAL-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 912, + "level": "MUST", + "text_digest": "aea822da3d", + "clause": "In successful responses, the host **MUST** supply a partial update to the `checkout` object, updating only the instrument indicated by `payment.selected_instrument_id` with the new `credentials` field." + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 986, + "level": "MUST", + "text_digest": "22353ff600" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1121, + "level": "MUST", + "text_digest": "22353ff600" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1132, + "level": "MUST", + "text_digest": "22353ff600" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0213", + "text_digest": "03e22bb1c3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "The Embedded Checkout **MUST** treat this update as a PUT-style change by entirely replacing the existing state for `payment.instruments`, rather than attempting to merge the new data with existing state.", + "normalized": "the embedded checkout must treat this update as a put-style change by entirely replacing the existing state for payment.instruments, rather than attempting to merge the new data with existing state", + "condition": null, + "referenced_fields": [ + "payment.instruments" + ], + "compound_parent": null, + "document_order": 370, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1132, + "end_line": 1138, + "section": "Checkout Capability - EP Binding > Payment Extension > Payment Message API Reference > `ec.payment.credential_request`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecpaymentcredential_request" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-PAYMENT-CREDENTIAL-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 912, + "level": "MUST", + "text_digest": "03e22bb1c3" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 986, + "level": "MUST", + "text_digest": "03e22bb1c3" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1121, + "level": "MUST", + "text_digest": "03e22bb1c3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1132, + "level": "MUST", + "text_digest": "03e22bb1c3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0214", + "text_digest": "a207de5e37", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **MUST NOT** silently release a token based solely on the message.", + "normalized": "the host must not silently release a token based solely on the message", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Host responsibilities during payment token delegation:**", + "document_order": 382, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1207, + "end_line": 1209, + "section": "Checkout Capability - EP Binding > Payment Extension > Payment Message API Reference > `ec.payment.credential_request`", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecpaymentcredential_request" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-PAYMENT-CREDENTIAL-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 974, + "level": "MUST NOT", + "text_digest": "44a3475bda", + "clause": "The host **MUST NOT** silently release a token based solely on the message." + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1050, + "level": "MUST NOT", + "text_digest": "a207de5e37" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1194, + "level": "MUST NOT", + "text_digest": "a207de5e37" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1207, + "level": "MUST NOT", + "text_digest": "a207de5e37" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0215", + "text_digest": "3060692cd2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **MUST** respond with either an error, or the newly-selected address.", + "normalized": "the host must respond with either an error, or the newly-selected address", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 415, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1325, + "end_line": 1331, + "section": "Checkout Capability - EP Binding > Fulfillment Extension > Fulfillment Message API Reference > `ec.fulfillment.address_change_request`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecfulfillmentaddress_change_request" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-FULFILLMENT-ADDRESS-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1091, + "level": "MUST", + "text_digest": "3060692cd2" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1167, + "level": "MUST", + "text_digest": "3060692cd2" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1311, + "level": "MUST", + "text_digest": "3060692cd2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1324, + "level": "MUST", + "text_digest": "3060692cd2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0216", + "text_digest": "2f14a5d57a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "In successful responses, the host **MUST** respond with an updated `fulfillment.methods` object, updating the `selected_destination_id` and `destinations` fields for fulfillment methods, and otherwise preserving the existing state.", + "normalized": "in successful responses, the host must respond with an updated fulfillment.methods object, updating the selected_destination_id and destinations fields for fulfillment methods, and otherwise preserving the existing state", + "condition": null, + "referenced_fields": [ + "destinations", + "fulfillment.methods", + "selected_destination_id" + ], + "compound_parent": null, + "document_order": 416, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1325, + "end_line": 1331, + "section": "Checkout Capability - EP Binding > Fulfillment Extension > Fulfillment Message API Reference > `ec.fulfillment.address_change_request`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecfulfillmentaddress_change_request" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-FULFILLMENT-ADDRESS-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1091, + "level": "MUST", + "text_digest": "2f14a5d57a" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1167, + "level": "MUST", + "text_digest": "2f14a5d57a" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1311, + "level": "MUST", + "text_digest": "2f14a5d57a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1324, + "level": "MUST", + "text_digest": "2f14a5d57a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0217", + "text_digest": "fd862f1fd7", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "The Embedded Checkout **MUST** treat this update as a PUT-style change by entirely replacing the existing state for `fulfillment.methods`, rather than attempting to merge the new data with existing state.", + "normalized": "the embedded checkout must treat this update as a put-style change by entirely replacing the existing state for fulfillment.methods, rather than attempting to merge the new data with existing state", + "condition": null, + "referenced_fields": [ + "fulfillment.methods" + ], + "compound_parent": null, + "document_order": 417, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1325, + "end_line": 1331, + "section": "Checkout Capability - EP Binding > Fulfillment Extension > Fulfillment Message API Reference > `ec.fulfillment.address_change_request`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "ecfulfillmentaddress_change_request" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-EC-FULFILLMENT-ADDRESS-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1091, + "level": "MUST", + "text_digest": "fd862f1fd7" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1167, + "level": "MUST", + "text_digest": "fd862f1fd7" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1311, + "level": "MUST", + "text_digest": "fd862f1fd7" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1324, + "level": "MUST", + "text_digest": "fd862f1fd7" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0218", + "text_digest": "f863ba3cef", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "When a checkout URL includes `ec_delegate=window.open`, the host **MUST** handle every `ec.window.open_request` and acknowledge the request.", + "normalized": "when a checkout url includes ec_delegate=window.open, the host must handle every ec.window.open_request and acknowledge the request", + "condition": "When a checkout URL includes `ec_delegate=window.open`", + "referenced_fields": [ + "ec.window.open_request" + ], + "compound_parent": null, + "document_order": 430, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1404, + "end_line": 1407, + "section": "Checkout Capability - EP Binding > Window Extension", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "window-extension" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-WINDOW-EXTENSION-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1387, + "level": "MUST", + "text_digest": "f863ba3cef" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1402, + "level": "MUST", + "text_digest": "f863ba3cef" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0219", + "text_digest": "be256dd9cb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.8, + "clause": "**MUST** send `ec.window.open_request` when the buyer activates a link presented by the business", + "normalized": "must send ec.window.open_request when the buyer activates a link presented by the business", + "condition": "when the buyer activates a link presented by the business", + "referenced_fields": [ + "ec.window.open_request" + ], + "compound_parent": "**Embedded Checkout responsibilities**:", + "document_order": 441, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1427, + "end_line": 1428, + "section": "Checkout Capability - EP Binding > Window Extension > Window Overview & Host Choice", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "window-overview-host-choice" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-WINDOW-OVERVIEW-HOST-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1410, + "level": "MUST", + "text_digest": "be256dd9cb" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1425, + "level": "MUST", + "text_digest": "be256dd9cb" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0220", + "text_digest": "f74c8b5260", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.8, + "clause": "**MUST** validate that the requested URL uses the `https` scheme", + "normalized": "must validate that the requested url uses the https scheme", + "condition": null, + "referenced_fields": [ + "https" + ], + "compound_parent": "**Host responsibilities**:", + "document_order": 443, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1432, + "end_line": 1432, + "section": "Checkout Capability - EP Binding > Window Extension > Window Overview & Host Choice", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "window-overview-host-choice" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-WINDOW-OVERVIEW-HOST-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1415, + "level": "MUST", + "text_digest": "f74c8b5260" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1430, + "level": "MUST", + "text_digest": "f74c8b5260" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0221", + "text_digest": "ac546d4675", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "HOST", + "actor_confidence": 0.8, + "clause": "**SHOULD** apply additional host security policies (e.g., verifying origins)", + "normalized": "should apply additional host security policies (e.g., verifying origins)", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Host responsibilities**:", + "document_order": 444, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1433, + "end_line": 1434, + "section": "Checkout Capability - EP Binding > Window Extension > Window Overview & Host Choice", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "window-overview-host-choice" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-WINDOW-OVERVIEW-HOST-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1416, + "level": "SHOULD", + "text_digest": "ac546d4675" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1431, + "level": "SHOULD", + "text_digest": "ac546d4675" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0222", + "text_digest": "1e520ee6a8", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.8, + "clause": "**MUST** present the content to the buyer for every approved request (e.g., in a modal, new tab, or similar)", + "normalized": "must present the content to the buyer for every approved request (e.g., in a modal, new tab, or similar)", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Host responsibilities**:", + "document_order": 445, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1435, + "end_line": 1436, + "section": "Checkout Capability - EP Binding > Window Extension > Window Overview & Host Choice", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "window-overview-host-choice" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-WINDOW-OVERVIEW-HOST-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1418, + "level": "MUST", + "text_digest": "1e520ee6a8" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1433, + "level": "MUST", + "text_digest": "1e520ee6a8" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0223", + "text_digest": "df7a51899a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "HOST", + "actor_confidence": 0.8, + "clause": "**MUST** respond with a JSON-RPC success result when the request was processed, or a `window_open_rejected_error` error if host policy prevented the navigation", + "normalized": "must respond with a json-rpc success result when the request was processed, or a window_open_rejected_error error if host policy prevented the navigation", + "condition": "when the request was processed, or a `window_open_rejected_error` error if host policy prevented the navigation", + "referenced_fields": [ + "window_open_rejected_error" + ], + "compound_parent": "**Host responsibilities**:", + "document_order": 446, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1437, + "end_line": 1439, + "section": "Checkout Capability - EP Binding > Window Extension > Window Overview & Host Choice", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "window-overview-host-choice" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-WINDOW-OVERVIEW-HOST-05", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1420, + "level": "MUST", + "text_digest": "df7a51899a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1435, + "level": "MUST", + "text_digest": "df7a51899a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0224", + "text_digest": "55e3e568a0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "HOST", + "actor_confidence": 0.8, + "clause": "**MAY** notify the buyer if the request was rejected", + "normalized": "may notify the buyer if the request was rejected", + "condition": "if the request was rejected", + "referenced_fields": [], + "compound_parent": "**Host responsibilities**:", + "document_order": 447, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1440, + "end_line": 1440, + "section": "Checkout Capability - EP Binding > Window Extension > Window Overview & Host Choice", + "block_type": "list_item", + "page": "specification/shopping/checkout/embedded/", + "anchor": "window-overview-host-choice" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-WINDOW-OVERVIEW-HOST-06", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1423, + "level": "MAY", + "text_digest": "55e3e568a0" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1438, + "level": "MAY", + "text_digest": "55e3e568a0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0225", + "text_digest": "cf9241666a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "EMBEDDED_CHECKOUT", + "actor_confidence": 0.9, + "clause": "The Embedded Checkout **MUST NOT** present its own UI for the link.", + "normalized": "the embedded checkout must not present its own ui for the link", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 449, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1442, + "end_line": 1444, + "section": "Checkout Capability - EP Binding > Window Extension > Window Overview & Host Choice", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "window-overview-host-choice" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-WINDOW-OVERVIEW-HOST-07", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1425, + "level": "MUST NOT", + "text_digest": "cf9241666a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1440, + "level": "MUST NOT", + "text_digest": "cf9241666a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0226", + "text_digest": "1e42c2ea27", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "Hosts that need richer context (e.g., link type or label) **MAY** cross-reference the requested URL against the `checkout.links` array from the checkout session to obtain additional metadata.", + "normalized": "hosts that need richer context (e.g., link type or label) may cross-reference the requested url against the checkout.links array from the checkout session to obtain additional metadata", + "condition": null, + "referenced_fields": [ + "checkout.links" + ], + "compound_parent": null, + "document_order": 451, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1446, + "end_line": 1449, + "section": "Checkout Capability - EP Binding > Window Extension > Window Overview & Host Choice", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "window-overview-host-choice" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-WINDOW-OVERVIEW-HOST-08", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1429, + "level": "MAY", + "text_digest": "1e42c2ea27" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1444, + "level": "MAY", + "text_digest": "1e42c2ea27" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0227", + "text_digest": "95b351b8f1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host **MAY** notify the buyer that their request was rejected.", + "normalized": "the host may notify the buyer that their request was rejected", + "condition": null, + "referenced_fields": [], + "compound_parent": "`window_open_rejected_error` | Description", + "document_order": 474, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1526, + "end_line": 1526, + "section": "Checkout Capability - EP Binding > Security & Error Handling > Error Codes", + "block_type": "table_cell", + "page": "specification/shopping/checkout/embedded/", + "anchor": "error-codes" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-ERROR-CODES-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "embedded", + "testable": false, + "testable_reason": "embedded protocol page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1506, + "level": "MAY", + "text_digest": "95b351b8f1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1524, + "level": "MAY", + "text_digest": "95b351b8f1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0228", + "text_digest": "8f97f24d67", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "HOST", + "actor_confidence": 0.9, + "clause": "The host SHOULD display a User Confirmation UI before releasing the token.", + "normalized": "the host should display a user confirmation ui before releasing the token", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 480, + "source": { + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1543, + "end_line": 1547, + "section": "Checkout Capability - EP Binding > Security & Error Handling > Prevention of Unsolicited Payment Requests", + "block_type": "paragraph", + "page": "specification/shopping/checkout/embedded/", + "anchor": "prevention-of-unsolicited-payment-requests" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EP-PREVENTION-OF-01", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "embedded", + "testable": false, + "testable_reason": "reviewed: aimed at the host", + "review": { + "verdict": "rule", + "actor": "HOST", + "testable": false, + "reason": "aimed at the host" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1236, + "level": "SHOULD", + "text_digest": "8f97f24d67" + }, + { + "version": "2026-01-23", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1311, + "level": "SHOULD", + "text_digest": "8f97f24d67" + }, + { + "version": "2026-04-08", + "file": "docs/specification/embedded-checkout.md", + "start_line": 1523, + "level": "SHOULD", + "text_digest": "8f97f24d67" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/embedded.md", + "start_line": 1541, + "level": "SHOULD", + "text_digest": "8f97f24d67" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/checkout/index.json b/requirements/catalog/shopping/checkout/index.json new file mode 100644 index 0000000..824f68f --- /dev/null +++ b/requirements/catalog/shopping/checkout/index.json @@ -0,0 +1,8285 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/checkout/index.md", + "summary": { + "total": 150, + "must_count": 52, + "must_not_count": 19, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 41, + "should_not_count": 0, + "may_count": 38, + "by_level": { + "MAY": 38, + "MUST": 52, + "MUST NOT": 19, + "SHOULD": 41 + }, + "by_actor": { + "BUSINESS": 50, + "BUYER": 1, + "EXTENSION": 1, + "PLATFORM": 57, + "UNRESOLVED": 41 + }, + "by_file": { + "docs/specification/shopping/checkout/index.md": 150 + }, + "with_condition": 45, + "with_referenced_fields": 76, + "from_compound_split": 22, + "diagnostics": { + "actor_after_keyword_only": 2, + "actor_low_confidence": 12, + "actor_unresolved": 41, + "annotation_as_obligation": 1, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 1, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 11, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CHECKOUT-0001", + "text_digest": "cd05227e99", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "**Discovering the sale basis.** The sale basis is item data: the Platform **SHOULD** discover an item's `quantity_unit` — including `scale` and any `increment` — from the [catalog](../catalog/index.md#sale-basis-and-quantity-units) before transacting.", + "normalized": "discovering the sale basis. the sale basis is item data: the platform should discover an item's quantity_unit - including scale and any increment - from the catalog before transacting", + "condition": null, + "referenced_fields": [ + "increment", + "quantity_unit", + "scale" + ], + "compound_parent": null, + "document_order": 21, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 80, + "end_line": 90, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 80, + "level": "SHOULD", + "text_digest": "cd05227e99" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0002", + "text_digest": "fb0415a3cb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MAY** include `quantity_unit` on a request line to assert the basis it believes it is ordering in.", + "normalized": "the platform may include quantity_unit on a request line to assert the basis it believes it is ordering in", + "condition": null, + "referenced_fields": [ + "quantity_unit" + ], + "compound_parent": null, + "document_order": 27, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 98, + "end_line": 104, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 98, + "level": "MAY", + "text_digest": "fb0415a3cb" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0003", + "text_digest": "62ebd6174e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When the Platform includes it, the Business **MUST** compare the asserted and authoritative [machine identities](../../overview/index.md#quantities-and-units).", + "normalized": "when the platform includes it, the business must compare the asserted and authoritative machine identities", + "condition": "When the Platform includes it", + "referenced_fields": [], + "compound_parent": null, + "document_order": 28, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 98, + "end_line": 104, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 98, + "level": "MUST", + "text_digest": "62ebd6174e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0004", + "text_digest": "6ef3b4aed5", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "**Convert, visibly.** When the Business can convert the asserted basis to its authoritative basis (for example, pounds to kilograms), it **MAY** apply the request as a visible line revision: the line carries the authoritative descriptor and the converted quantity — rounded once to the authoritative `scale` according to its rules, with any ordering-increment policy applied after conversion — and the response includes a warning `messages[]` entry at the line.", + "normalized": "convert, visibly. when the business can convert the asserted basis to its authoritative basis (for example, pounds to kilograms), it may apply the request as a visible line revision: the line carries the authoritative descriptor and the converted quantity - rounded once to the authoritative scale according to its rules, with any ordering-increment policy applied after conversion - and the response includes a warning messages[] entry at the line", + "condition": "When the Business can convert the asserted basis to its authoritative basis (for example, pounds to kilograms)", + "referenced_fields": [ + "messages[]", + "scale" + ], + "compound_parent": "If an asserted `quantity_unit` does not match the item's authoritative sale basis, the requested quantity is denominated in a basis the Business does not sell in. Silent conversion is forbidden in both directions: neither party may reinterpret a quantity the other denominated without surfacing the change. The Business resolves the mismatch in one of two ways:", + "document_order": 33, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 112, + "end_line": 119, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 112, + "level": "MAY", + "text_digest": "6ef3b4aed5" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0005", + "text_digest": "95f6f6314f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "**Reject, recoverably.** When it cannot or chooses not to convert (for example, a quantity of fasteners denominated in litres), the Business **MUST** reject the request's effect on that line with a recoverable business outcome naming the authoritative basis.", + "normalized": "reject, recoverably. when it cannot or chooses not to convert (for example, a quantity of fasteners denominated in litres), the business must reject the request's effect on that line with a recoverable business outcome naming the authoritative basis", + "condition": "When it cannot or chooses not to convert (for example, a quantity of fasteners denominated in litres)", + "referenced_fields": [], + "compound_parent": "If an asserted `quantity_unit` does not match the item's authoritative sale basis, the requested quantity is denominated in a basis the Business does not sell in. Silent conversion is forbidden in both directions: neither party may reinterpret a quantity the other denominated without surfacing the change. The Business resolves the mismatch in one of two ways:", + "document_order": 35, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 120, + "end_line": 126, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-05", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 120, + "level": "MUST", + "text_digest": "95f6f6314f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0006", + "text_digest": "9f67312357", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "On create, the line is not created and the message identifies the item in `content`; when no line can be created, the Business **MAY** return an error response instead.", + "normalized": "on create, the line is not created and the message identifies the item in content; when no line can be created, the business may return an error response instead", + "condition": "when no line can be created", + "referenced_fields": [ + "content" + ], + "compound_parent": "If an asserted `quantity_unit` does not match the item's authoritative sale basis, the requested quantity is denominated in a basis the Business does not sell in. Silent conversion is forbidden in both directions: neither party may reinterpret a quantity the other denominated without surfacing the change. The Business resolves the mismatch in one of two ways:", + "document_order": 37, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 120, + "end_line": 126, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-06", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 120, + "level": "MAY", + "text_digest": "9f67312357" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0007", + "text_digest": "369ccf093d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**Ordering increment.** The sale basis **MAY** declare an [`increment`](../../overview/index.md#ordering-increment) — the ordering granularity, in steps, the Business sells in.", + "normalized": "ordering increment. the sale basis may declare an increment - the ordering granularity, in steps, the business sells in", + "condition": null, + "referenced_fields": [ + "increment" + ], + "compound_parent": null, + "document_order": 46, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "end_line": 255, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-07", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on response content" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "level": "MAY", + "text_digest": "369ccf093d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0008", + "text_digest": "be19f9b8ba", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platform-authored quantities **SHOULD** be integer multiples of the line's effective increment.", + "normalized": "platform-authored quantities should be integer multiples of the line's effective increment", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 48, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "end_line": 255, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-08", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "level": "SHOULD", + "text_digest": "be19f9b8ba" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0009", + "text_digest": "471fb3330b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The increment is merchandising policy, not a representational bound, and schema validation does not enforce it: on receiving an off-increment quantity, the Business **MAY** accept it, revise the line to an increment multiple, or reject it with a recoverable business outcome.", + "normalized": "the increment is merchandising policy, not a representational bound, and schema validation does not enforce it: on receiving an off-increment quantity, the business may accept it, revise the line to an increment multiple, or reject it with a recoverable business outcome", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 49, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "end_line": 255, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-09", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "level": "MAY", + "text_digest": "471fb3330b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0010", + "text_digest": "dec45589b9", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "A revision **MUST** be returned as a revised line `quantity` with an explanatory `messages[]` entry", + "normalized": "a revision must be returned as a revised line quantity with an explanatory messages[] entry", + "condition": null, + "referenced_fields": [ + "messages[]", + "quantity" + ], + "compound_parent": null, + "document_order": 50, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "end_line": 255, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-10", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: response content when the business revises a quantity", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content when the business revises a quantity" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "level": "MUST", + "text_digest": "dec45589b9" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0011", + "text_digest": "4c7e4ba353", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "the Business **MUST NOT** silently reinterpret the requested quantity.", + "normalized": "the business must not silently reinterpret the requested quantity", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 50, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "end_line": 255, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-11", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "level": "MUST NOT", + "text_digest": "4c7e4ba353" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0012", + "text_digest": "dd9079f287", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MAY** also revise a quantity for its own reasons (for example, limited stock)", + "normalized": "the business may also revise a quantity for its own reasons (for example, limited stock)", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 51, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "end_line": 255, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-12", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "level": "MAY", + "text_digest": "dd9079f287" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0013", + "text_digest": "8becb2a472", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "such revisions **SHOULD** stay on the increment grid so subsequent Platform stepper edits from the revised value remain on-grid.", + "normalized": "such revisions should stay on the increment grid so subsequent platform stepper edits from the revised value remain on-grid", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 51, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "end_line": 255, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-13", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 242, + "level": "SHOULD", + "text_digest": "8becb2a472" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0014", + "text_digest": "f8e51f41e6", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "**Echoing the sale basis.** The Business **MAY** omit `quantity_unit` from a response line whose effective sale-basis identity is the default identity.", + "normalized": "echoing the sale basis. the business may omit quantity_unit from a response line whose effective sale-basis identity is the default identity", + "condition": null, + "referenced_fields": [ + "quantity_unit" + ], + "compound_parent": null, + "document_order": 54, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 274, + "end_line": 279, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-14", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 274, + "level": "MAY", + "text_digest": "f8e51f41e6" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0015", + "text_digest": "3bb377c529", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MUST** include `quantity_unit` on the item in every Cart, Checkout, and Order line response whenever the effective identity differs from the default identity.", + "normalized": "the business must include quantity_unit on the item in every cart, checkout, and order line response whenever the effective identity differs from the default identity", + "condition": "whenever the effective identity differs from the default identity", + "referenced_fields": [ + "quantity_unit" + ], + "compound_parent": null, + "document_order": 55, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 274, + "end_line": 279, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-15", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 274, + "level": "MUST", + "text_digest": "3bb377c529" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0016", + "text_digest": "a3b9edd660", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MUST** compute the line total as `price × quantity × 10^-scale` and round once at the line.", + "normalized": "the business must compute the line total as price × quantity × 10^-scale and round once at the line", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 59, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 281, + "end_line": 289, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-16", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 281, + "level": "MUST", + "text_digest": "a3b9edd660" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0017", + "text_digest": "3ebe3248f4", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST NOT** recompute a line total from the fractional quantity and substitute its own rounding.", + "normalized": "the platform must not recompute a line total from the fractional quantity and substitute its own rounding", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 61, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 281, + "end_line": 289, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-17", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 281, + "level": "MUST NOT", + "text_digest": "3ebe3248f4" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0018", + "text_digest": "da38167665", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "**Pricing basis.** `item.price` is always denominated against the sale basis, but the Business MAY quote it from a different measurement basis — for example, apples priced per pound and sold per `each`.", + "normalized": "pricing basis. item.price is always denominated against the sale basis, but the business may quote it from a different measurement basis - for example, apples priced per pound and sold per each", + "condition": null, + "referenced_fields": [ + "each", + "item.price" + ], + "compound_parent": null, + "document_order": 62, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 291, + "end_line": 300, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-18", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; visible when used", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 291, + "level": "MAY", + "text_digest": "da38167665" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0019", + "text_digest": "bd31c0f360", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "On authoritative responses the Business **MUST** include `item.unit_price` on every cart, checkout, and order line whose pricing basis differs from its sale basis: the rate that determines the charge travels with the line, exactly as the sale basis itself does.", + "normalized": "on authoritative responses the business must include item.unit_price on every cart, checkout, and order line whose pricing basis differs from its sale basis: the rate that determines the charge travels with the line, exactly as the sale basis itself does", + "condition": null, + "referenced_fields": [ + "item.unit_price" + ], + "compound_parent": null, + "document_order": 63, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 291, + "end_line": 300, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-19", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 291, + "level": "MUST", + "text_digest": "bd31c0f360" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0020", + "text_digest": "bbea25f035", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When the pricing basis is the sale basis, `unit_price` remains a catalog display comparator and MAY be omitted from lines.", + "normalized": "when the pricing basis is the sale basis, unit_price remains a catalog display comparator and may be omitted from lines", + "condition": "When the pricing basis is the sale basis", + "referenced_fields": [ + "unit_price" + ], + "compound_parent": null, + "document_order": 64, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 291, + "end_line": 300, + "section": "Checkout Capability > Overview > Quantity and sale basis", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "quantity-and-sale-basis" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-QUANTITY-AND-SALE-BASIS-20", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on response content" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 291, + "level": "MAY", + "text_digest": "bbea25f035" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0021", + "text_digest": "af51ddc764", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The response **MUST NOT** contain `order`.", + "normalized": "the response must not contain order", + "condition": null, + "referenced_fields": [ + "order" + ], + "compound_parent": null, + "document_order": 86, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 397, + "end_line": 400, + "section": "Checkout Capability > Overview > Status Values", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "status-values" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-STATUS-VALUES-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 397, + "level": "MUST NOT", + "text_digest": "af51ddc764" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0022", + "text_digest": "d424fedfda", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "After processing the Action according to its Action type's contract, the Platform **SHOULD** use [Get Checkout](#get-checkout) or, outside `complete_in_progress`, a subsequent [Update Checkout](#update-checkout) response to obtain the latest Checkout.", + "normalized": "after processing the action according to its action type's contract, the platform should use get checkout or, outside complete_in_progress, a subsequent update checkout response to obtain the latest checkout", + "condition": null, + "referenced_fields": [ + "complete_in_progress" + ], + "compound_parent": null, + "document_order": 101, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 418, + "end_line": 423, + "section": "Checkout Capability > Overview > Actions", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "actions" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACTIONS-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 418, + "level": "SHOULD", + "text_digest": "d424fedfda" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0023", + "text_digest": "1c657a54ec", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "If an Action prevents Complete Checkout from being accepted, the Business **MUST** return the current Checkout with `status: incomplete` and an error Message with `severity: \"recoverable\"` whose `path` selects that exact Action occurrence.", + "normalized": "if an action prevents complete checkout from being accepted, the business must return the current checkout with status: incomplete and an error message with severity: \"recoverable\" whose path selects that exact action occurrence", + "condition": "If an Action prevents Complete Checkout from being accepted", + "referenced_fields": [ + "path", + "severity", + "status" + ], + "compound_parent": null, + "document_order": 108, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 435, + "end_line": 440, + "section": "Checkout Capability > Overview > Actions", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "actions" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACTIONS-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 435, + "level": "MUST", + "text_digest": "1c657a54ec" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0024", + "text_digest": "525a30062e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MAY** invoke Get Checkout; the Business's response is authoritative.", + "normalized": "the platform may invoke get checkout; the business's response is authoritative", + "condition": null, + "referenced_fields": [], + "compound_parent": "Get Checkout | Contract", + "document_order": 115, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 450, + "end_line": 450, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 450, + "level": "MAY", + "text_digest": "525a30062e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0025", + "text_digest": "3bd78d0877", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MAY** repeat Get Checkout with bounded backoff set by the Action contract or Platform policy", + "normalized": "the platform may repeat get checkout with bounded backoff set by the action contract or platform policy", + "condition": null, + "referenced_fields": [], + "compound_parent": "Get Checkout | Contract", + "document_order": 116, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 450, + "end_line": 450, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 450, + "level": "MAY", + "text_digest": "3bd78d0877" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0026", + "text_digest": "e94f7b7609", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST** stop repeated requests at `expires_at`.", + "normalized": "the platform must stop repeated requests at expires_at", + "condition": null, + "referenced_fields": [ + "expires_at" + ], + "compound_parent": "Get Checkout | Contract", + "document_order": 116, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 450, + "end_line": 450, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 450, + "level": "MUST", + "text_digest": "e94f7b7609" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0027", + "text_digest": "ccf0b15003", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST NOT** start a new Update Checkout operation.", + "normalized": "the platform must not start a new update checkout operation", + "condition": null, + "referenced_fields": [], + "compound_parent": "Update Checkout | Contract", + "document_order": 118, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 451, + "end_line": 451, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 451, + "level": "MUST NOT", + "text_digest": "ccf0b15003" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0028", + "text_digest": "58f10a1130", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "If the Business receives a new Update Checkout request, it **MUST** leave the Checkout unchanged and return the current Checkout with a recoverable error Message.", + "normalized": "if the business receives a new update checkout request, it must leave the checkout unchanged and return the current checkout with a recoverable error message", + "condition": "If the Business receives a new Update Checkout request", + "referenced_fields": [], + "compound_parent": "Update Checkout | Contract", + "document_order": 120, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 451, + "end_line": 451, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-05", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 451, + "level": "MUST", + "text_digest": "58f10a1130" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0029", + "text_digest": "7e560a0d63", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST NOT** start a new Complete Checkout operation during `complete_in_progress`.", + "normalized": "the platform must not start a new complete checkout operation during complete_in_progress", + "condition": null, + "referenced_fields": [ + "complete_in_progress" + ], + "compound_parent": "Complete Checkout | Contract", + "document_order": 122, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 452, + "end_line": 452, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-06", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 452, + "level": "MUST NOT", + "text_digest": "7e560a0d63" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0030", + "text_digest": "4441824ed1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST** follow the fallback, handoff, and cancellation race rules below before attempting Cancel Checkout.", + "normalized": "the platform must follow the fallback, handoff, and cancellation race rules below before attempting cancel checkout", + "condition": null, + "referenced_fields": [], + "compound_parent": "Cancel Checkout | Contract", + "document_order": 125, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 453, + "end_line": 453, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-07", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 453, + "level": "MUST", + "text_digest": "4441824ed1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0031", + "text_digest": "b392324c48", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "When it contains no Action, the Platform **SHOULD** use Get Checkout to observe Business processing.", + "normalized": "when it contains no action, the platform should use get checkout to observe business processing", + "condition": "When it contains no Action", + "referenced_fields": [], + "compound_parent": null, + "document_order": 127, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 455, + "end_line": 457, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-08", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 455, + "level": "SHOULD", + "text_digest": "b392324c48" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0032", + "text_digest": "12329820ba", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Because Update Checkout is unavailable after Complete Checkout is accepted, the Business **MUST** surface any Action that requires input through Update Checkout before accepting Complete Checkout.", + "normalized": "because update checkout is unavailable after complete checkout is accepted, the business must surface any action that requires input through update checkout before accepting complete checkout", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 128, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 459, + "end_line": 461, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-09", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 459, + "level": "MUST", + "text_digest": "12329820ba" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0033", + "text_digest": "e92495e10d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST** use [Get Checkout](#get-checkout) to confirm that the Business reflected the result, for example by removing the Action or changing the Checkout status.", + "normalized": "the platform must use get checkout to confirm that the business reflected the result, for example by removing the action or changing the checkout status", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 131, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 463, + "end_line": 467, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-10", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 463, + "level": "MUST", + "text_digest": "e92495e10d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0034", + "text_digest": "e937ec9401", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "If the same Action key and `id` remain, the Platform **MUST NOT** process it again unless its contract explicitly permits retry and every safe-retry condition holds.", + "normalized": "if the same action key and id remain, the platform must not process it again unless its contract explicitly permits retry and every safe-retry condition holds", + "condition": "If the same Action key and `id` remain", + "referenced_fields": [ + "id" + ], + "compound_parent": null, + "document_order": 132, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 469, + "end_line": 472, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-11", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 469, + "level": "MUST NOT", + "text_digest": "e937ec9401" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0035", + "text_digest": "0f80aad830", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "If the Platform cannot complete an Action, or the Business does not update the Checkout within a timeout set by the Action contract or Platform policy before `expires_at`, the Platform **SHOULD** follow any applicable Action fallback.", + "normalized": "if the platform cannot complete an action, or the business does not update the checkout within a timeout set by the action contract or platform policy before expires_at, the platform should follow any applicable action fallback", + "condition": "If the Platform cannot complete an Action", + "referenced_fields": [ + "expires_at" + ], + "compound_parent": null, + "document_order": 135, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 474, + "end_line": 480, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-12", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 474, + "level": "SHOULD", + "text_digest": "0f80aad830" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0036", + "text_digest": "afaf5a02f1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "If no fallback can continue the Checkout and `continue_url` is available, the Platform **SHOULD** use it to hand off the Checkout to the Buyer.", + "normalized": "if no fallback can continue the checkout and continue_url is available, the platform should use it to hand off the checkout to the buyer", + "condition": "If no fallback can continue the Checkout and `continue_url` is available", + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 136, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 474, + "end_line": 480, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-13", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 474, + "level": "SHOULD", + "text_digest": "afaf5a02f1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0037", + "text_digest": "f4423ba09c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST NOT** attempt Cancel Checkout while either fallback or handoff can still continue the Checkout.", + "normalized": "the platform must not attempt cancel checkout while either fallback or handoff can still continue the checkout", + "condition": "while either fallback or handoff can still continue the Checkout", + "referenced_fields": [], + "compound_parent": null, + "document_order": 137, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 474, + "end_line": 480, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-14", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 474, + "level": "MUST NOT", + "text_digest": "f4423ba09c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0038", + "text_digest": "de9b426014", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "If neither fallback nor handoff can continue, the Platform **SHOULD** use Get Checkout to retrieve the latest state and attempt Cancel Checkout only if it still reports `complete_in_progress`.", + "normalized": "if neither fallback nor handoff can continue, the platform should use get checkout to retrieve the latest state and attempt cancel checkout only if it still reports complete_in_progress", + "condition": "If neither fallback nor handoff can continue", + "referenced_fields": [ + "complete_in_progress" + ], + "compound_parent": null, + "document_order": 138, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 482, + "end_line": 486, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-15", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 482, + "level": "SHOULD", + "text_digest": "de9b426014" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0039", + "text_digest": "37585e2cc9", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Cancellation can race completion; the Platform **MUST NOT** treat the Checkout as canceled unless the Business reports `status: canceled`.", + "normalized": "cancellation can race completion; the platform must not treat the checkout as canceled unless the business reports status: canceled", + "condition": "unless the Business reports `status: canceled`", + "referenced_fields": [ + "status" + ], + "compound_parent": null, + "document_order": 139, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 482, + "end_line": 486, + "section": "Checkout Capability > Overview > Actions > Accepted completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "accepted-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ACCEPTED-COMPLETION-16", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 482, + "level": "MUST NOT", + "text_digest": "37585e2cc9" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0040", + "text_digest": "68730700a3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When no resource exists to act on, messages SHOULD use `severity: \"unrecoverable\"`.", + "normalized": "when no resource exists to act on, messages should use severity: \"unrecoverable\"", + "condition": "When no resource exists to act on", + "referenced_fields": [ + "severity" + ], + "compound_parent": null, + "document_order": 161, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 515, + "end_line": 521, + "section": "Checkout Capability > Overview > Error Handling", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "error-handling" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ERROR-HANDLING-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: message severity in responses", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "message severity in responses" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 141, + "level": "SHOULD", + "text_digest": "68730700a3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 515, + "level": "SHOULD", + "text_digest": "68730700a3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0041", + "text_digest": "a66058228d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **SHOULD** surface such messages as early as possible", + "normalized": "businesses should surface such messages as early as possible", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 167, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 544, + "end_line": 554, + "section": "Checkout Capability > Overview > Error Handling > Error Processing Algorithm", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "error-processing-algorithm" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ERROR-PROCESSING-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 137, + "level": "SHOULD", + "text_digest": "a66058228d" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 142, + "level": "SHOULD", + "text_digest": "a66058228d" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 169, + "level": "SHOULD", + "text_digest": "a66058228d" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 544, + "level": "SHOULD", + "text_digest": "a66058228d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0042", + "text_digest": "1a84344de6", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "platforms **SHOULD** prioritize resolving recoverable errors before initiating handoff.", + "normalized": "platforms should prioritize resolving recoverable errors before initiating handoff", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 167, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 544, + "end_line": 554, + "section": "Checkout Capability > Overview > Error Handling > Error Processing Algorithm", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "error-processing-algorithm" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ERROR-PROCESSING-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 137, + "level": "SHOULD", + "text_digest": "1a84344de6" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 142, + "level": "SHOULD", + "text_digest": "1a84344de6" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 169, + "level": "SHOULD", + "text_digest": "1a84344de6" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 544, + "level": "SHOULD", + "text_digest": "1a84344de6" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0043", + "text_digest": "34664bbf7f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **SHOULD** mark standard errors with `severity: recoverable` to signal that platforms should provide appropriate UX (out-of-stock messaging, address validation prompts, payment method changes) rather than generic error messages or deferring to checkout completion.", + "normalized": "businesses should mark standard errors with severity: recoverable to signal that platforms should provide appropriate ux (out-of-stock messaging, address validation prompts, payment method changes) rather than generic error messages or deferring to checkout completion", + "condition": null, + "referenced_fields": [ + "severity" + ], + "compound_parent": null, + "document_order": 182, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 627, + "end_line": 630, + "section": "Checkout Capability > Overview > Error Handling > Standard Errors", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "standard-errors" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-STANDARD-ERRORS-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 245, + "level": "SHOULD", + "text_digest": "34664bbf7f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 627, + "level": "SHOULD", + "text_digest": "34664bbf7f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0044", + "text_digest": "f88ead9106", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "`path` **MUST** be an [RFC 9535](https://www.rfc-editor.org/rfc/rfc9535) JSONPath expression relative to the root of the UCP response object.", + "normalized": "path must be an rfc 9535 jsonpath expression relative to the root of the ucp response object", + "condition": null, + "referenced_fields": [ + "path" + ], + "compound_parent": null, + "document_order": 187, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 643, + "end_line": 645, + "section": "Checkout Capability > Overview > Error Handling > The `path` Field", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "the-path-field" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-THE-PATH-FIELD-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: message path in responses", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "message path in responses" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 643, + "level": "MUST", + "text_digest": "f88ead9106" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0045", + "text_digest": "a3efff7283", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When multiple errors apply to the same field, each message **SHOULD** carry the most specific path applicable.", + "normalized": "when multiple errors apply to the same field, each message should carry the most specific path applicable", + "condition": "When multiple errors apply to the same field", + "referenced_fields": [], + "compound_parent": null, + "document_order": 193, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 670, + "end_line": 673, + "section": "Checkout Capability > Overview > Error Handling > The `path` Field", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "the-path-field" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-THE-PATH-FIELD-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: message path in responses", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "message path in responses" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 670, + "level": "SHOULD", + "text_digest": "a3efff7283" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0046", + "text_digest": "8da7db45a5", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MAY** act on recognized claims during the session (adjusting pricing, granting product access, applying provisional discounts)", + "normalized": "businesses may act on recognized claims during the session (adjusting pricing, granting product access, applying provisional discounts)", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 196, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 677, + "end_line": 682, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 255, + "level": "MAY", + "text_digest": "8da7db45a5" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 677, + "level": "MAY", + "text_digest": "8da7db45a5" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0047", + "text_digest": "90b3974648", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "all accepted claims **MUST** be resolved before the transaction can complete.", + "normalized": "all accepted claims must be resolved before the transaction can complete", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 196, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 677, + "end_line": 682, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: completion is blocked until claims resolve", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: completion is blocked until claims resolve" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 255, + "level": "MUST", + "text_digest": "90b3974648" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 677, + "level": "MUST", + "text_digest": "90b3974648" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0048", + "text_digest": "ab6a714be7", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Unrecognized or inapplicable claims **MUST NOT** block the checkout.", + "normalized": "unrecognized or inapplicable claims must not block the checkout", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 197, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 684, + "end_line": 689, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: the checkout isn't blocked", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the checkout isn't blocked" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 262, + "level": "MUST NOT", + "text_digest": "ab6a714be7" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 684, + "level": "MUST NOT", + "text_digest": "ab6a714be7" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0049", + "text_digest": "80e3a8d49f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **SHOULD** notify the buyer via `messages` with `type: \"warning\"` when a claim is not accepted", + "normalized": "businesses should notify the buyer via messages with type: \"warning\" when a claim is not accepted", + "condition": "when a claim is not accepted", + "referenced_fields": [ + "messages", + "type" + ], + "compound_parent": null, + "document_order": 198, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 684, + "end_line": 689, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 262, + "level": "SHOULD", + "text_digest": "80e3a8d49f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 684, + "level": "SHOULD", + "text_digest": "80e3a8d49f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0050", + "text_digest": "39c0060e67", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MAY** use `type: \"info\"` to explain the effects of accepted claims.", + "normalized": "businesses may use type: \"info\" to explain the effects of accepted claims", + "condition": null, + "referenced_fields": [ + "type" + ], + "compound_parent": null, + "document_order": 198, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 684, + "end_line": 689, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-05", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 262, + "level": "MAY", + "text_digest": "39c0060e67" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 684, + "level": "MAY", + "text_digest": "39c0060e67" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0051", + "text_digest": "7ace1fe265", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "At completion, accepted claims that remain unverified **MUST** result in `type: \"error\"` with `code: \"eligibility_invalid\"` (see below).", + "normalized": "at completion, accepted claims that remain unverified must result in type: \"error\" with code: \"eligibility_invalid\" (see below)", + "condition": null, + "referenced_fields": [ + "code", + "type" + ], + "compound_parent": null, + "document_order": 199, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 684, + "end_line": 689, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-06", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: error code eligibility_invalid", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: error code eligibility_invalid" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 262, + "level": "MUST", + "text_digest": "7ace1fe265" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 684, + "level": "MUST", + "text_digest": "7ace1fe265" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0052", + "text_digest": "4e67dc5855", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MUST NOT** complete a transaction with unresolved eligibility claims.", + "normalized": "businesses must not complete a transaction with unresolved eligibility claims", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 217, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 709, + "end_line": 711, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-07", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 287, + "level": "MUST NOT", + "text_digest": "4e67dc5855" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 709, + "level": "MUST NOT", + "text_digest": "4e67dc5855" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0053", + "text_digest": "79e6b4f5b0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MUST** return an error in `messages` with `code: \"eligibility_invalid\"` and `severity: \"recoverable\"`.", + "normalized": "the business must return an error in messages with code: \"eligibility_invalid\" and severity: \"recoverable\"", + "condition": null, + "referenced_fields": [ + "code", + "messages", + "severity" + ], + "compound_parent": null, + "document_order": 220, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 715, + "end_line": 725, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-08", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 293, + "level": "MUST", + "text_digest": "79e6b4f5b0" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 715, + "level": "MUST", + "text_digest": "79e6b4f5b0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0054", + "text_digest": "11372efe76", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When an Action prevents the requested effect, the Business **MUST** set that error Message's `path` to select the exact Action occurrence as specified in [Actions](#actions).", + "normalized": "when an action prevents the requested effect, the business must set that error message's path to select the exact action occurrence as specified in actions", + "condition": "When an Action prevents the requested effect", + "referenced_fields": [ + "path" + ], + "compound_parent": null, + "document_order": 221, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 715, + "end_line": 725, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-09", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 715, + "level": "MUST", + "text_digest": "11372efe76" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0055", + "text_digest": "bb1452383a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Otherwise, the Business **SHOULD** use `path` to identify which specific claim(s) could not be verified.", + "normalized": "otherwise, the business should use path to identify which specific claim(s) could not be verified", + "condition": null, + "referenced_fields": [ + "path" + ], + "compound_parent": null, + "document_order": 222, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 715, + "end_line": 725, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-10", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 715, + "level": "SHOULD", + "text_digest": "bb1452383a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0056", + "text_digest": "daf94805c3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "EXTENSION", + "actor_confidence": 0.9, + "clause": "Any Action or discount state contributed by a negotiated extension **MAY** remain current according to that extension.", + "normalized": "any action or discount state contributed by a negotiated extension may remain current according to that extension", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 223, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 715, + "end_line": 725, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-11", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: defers to each extension's own rules; nothing to check here", + "review": { + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "defers to each extension's own rules; nothing to check here" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 715, + "level": "MAY", + "text_digest": "daf94805c3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0057", + "text_digest": "57ed2f5e33", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MAY** then retry that extension's verification flow, use [Update Checkout](#update-checkout) for ordinary checkout changes (e.g., remove ineligible items) or to rescind the claim, or abandon the attempt.", + "normalized": "the platform may then retry that extension's verification flow, use update checkout for ordinary checkout changes (e.g., remove ineligible items) or to rescind the claim, or abandon the attempt", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 224, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 715, + "end_line": 725, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "eligibility-verification-at-completion" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-ELIGIBILITY-VERIFICATION-12", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 715, + "level": "MAY", + "text_digest": "57ed2f5e33" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0058", + "text_digest": "c00cb541a5", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "With the claim resolved, the checkout **MAY** advance to `ready_for_complete`.", + "normalized": "with the claim resolved, the checkout may advance to ready_for_complete", + "condition": null, + "referenced_fields": [ + "ready_for_complete" + ], + "compound_parent": null, + "document_order": 236, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 793, + "end_line": 796, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion > Example: resolving a claim with a verification Action", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "example-resolving-a-claim-with-a-verification-action" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EXAMPLE-RESOLVING-A-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "not a rule (reviewed): narration inside a worked example", + "review": { + "verdict": "not a rule", + "actor": "BUSINESS", + "testable": false, + "reason": "narration inside a worked example" + }, + "excluded": true, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 793, + "level": "MAY", + "text_digest": "c00cb541a5" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0059", + "text_digest": "c9eeb1baa3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MAY** provide valid proof and retry the verification flow, or rescind the claim.", + "normalized": "the platform may provide valid proof and retry the verification flow, or rescind the claim", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 239, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 798, + "end_line": 802, + "section": "Checkout Capability > Overview > Error Handling > Eligibility Verification at Completion > Example: resolving a claim with a verification Action", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "example-resolving-a-claim-with-a-verification-action" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-EXAMPLE-RESOLVING-A-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 798, + "level": "MAY", + "text_digest": "c9eeb1baa3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0060", + "text_digest": "acfcf54c52", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The `presentation` field on warning messages controls the rendering contract the platform **MUST** follow.", + "normalized": "the presentation field on warning messages controls the rendering contract the platform must follow", + "condition": null, + "referenced_fields": [ + "presentation" + ], + "compound_parent": null, + "document_order": 241, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 810, + "end_line": 812, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 331, + "level": "MUST", + "text_digest": "acfcf54c52" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 810, + "level": "MUST", + "text_digest": "acfcf54c52" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0061", + "text_digest": "f1104000fd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST**", + "normalized": "must", + "condition": null, + "referenced_fields": [], + "compound_parent": "Display content | `notice` (default)", + "document_order": 244, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 816, + "end_line": 816, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: Warning Presentation table: how platforms render warnings", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 337, + "level": "MUST", + "text_digest": "f1104000fd" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 816, + "level": "MUST", + "text_digest": "f1104000fd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0062", + "text_digest": "2c5d9d6629", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST**", + "normalized": "must", + "condition": null, + "referenced_fields": [], + "compound_parent": "Display content | `disclosure`", + "document_order": 245, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 816, + "end_line": 816, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: Warning Presentation table: how platforms render warnings", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 337, + "level": "MUST", + "text_digest": "2c5d9d6629" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 816, + "level": "MUST", + "text_digest": "2c5d9d6629" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0063", + "text_digest": "16da19e571", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MAY**", + "normalized": "may", + "condition": null, + "referenced_fields": [], + "compound_parent": "Proximity to `path` | `notice` (default)", + "document_order": 247, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 817, + "end_line": 817, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: Warning Presentation table: how platforms render warnings", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 338, + "level": "MAY", + "text_digest": "16da19e571" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 817, + "level": "MAY", + "text_digest": "16da19e571" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0064", + "text_digest": "3214a8b4f3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST**", + "normalized": "must", + "condition": null, + "referenced_fields": [], + "compound_parent": "Proximity to `path` | `disclosure`", + "document_order": 248, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 817, + "end_line": 817, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-05", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: Warning Presentation table: how platforms render warnings", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 338, + "level": "MUST", + "text_digest": "3214a8b4f3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 817, + "level": "MUST", + "text_digest": "3214a8b4f3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0065", + "text_digest": "f2580192f4", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MAY**", + "normalized": "may", + "condition": null, + "referenced_fields": [], + "compound_parent": "Dismissible | `notice` (default)", + "document_order": 250, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 818, + "end_line": 818, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-06", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: Warning Presentation table: how platforms render warnings", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 339, + "level": "MAY", + "text_digest": "f2580192f4" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 818, + "level": "MAY", + "text_digest": "f2580192f4" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0066", + "text_digest": "454e178f36", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST NOT**", + "normalized": "must not", + "condition": null, + "referenced_fields": [], + "compound_parent": "Dismissible | `disclosure`", + "document_order": 251, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 818, + "end_line": 818, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-07", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: Warning Presentation table: how platforms render warnings", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 339, + "level": "MUST NOT", + "text_digest": "454e178f36" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 818, + "level": "MUST NOT", + "text_digest": "454e178f36" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0067", + "text_digest": "164a7d0bf1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MAY**", + "normalized": "may", + "condition": null, + "referenced_fields": [], + "compound_parent": "Render `image_url` | `notice` (default)", + "document_order": 253, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 819, + "end_line": 819, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-08", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: Warning Presentation table: how platforms render warnings", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 340, + "level": "MAY", + "text_digest": "164a7d0bf1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 819, + "level": "MAY", + "text_digest": "164a7d0bf1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0068", + "text_digest": "22696563a2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST**", + "normalized": "must", + "condition": null, + "referenced_fields": [], + "compound_parent": "Render `image_url` | `disclosure`", + "document_order": 254, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 819, + "end_line": 819, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-09", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: Warning Presentation table: how platforms render warnings", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 340, + "level": "MUST", + "text_digest": "22696563a2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 819, + "level": "MUST", + "text_digest": "22696563a2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0069", + "text_digest": "1d6897ff8a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MAY**", + "normalized": "may", + "condition": null, + "referenced_fields": [], + "compound_parent": "Render `url` | `notice` (default)", + "document_order": 256, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 820, + "end_line": 820, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-10", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: Warning Presentation table: how platforms render warnings", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 341, + "level": "MAY", + "text_digest": "1d6897ff8a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 820, + "level": "MAY", + "text_digest": "1d6897ff8a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0070", + "text_digest": "93029fc74c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**SHOULD**", + "normalized": "should", + "condition": null, + "referenced_fields": [], + "compound_parent": "Render `url` | `disclosure`", + "document_order": 257, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 820, + "end_line": 820, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-11", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: Warning Presentation table: how platforms render warnings", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 341, + "level": "SHOULD", + "text_digest": "93029fc74c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 820, + "level": "SHOULD", + "text_digest": "93029fc74c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0071", + "text_digest": "d8320eb452", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** via `continue_url`", + "normalized": "must via continue_url", + "condition": null, + "referenced_fields": [ + "continue_url" + ], + "compound_parent": "Escalate if cannot honor | `disclosure`", + "document_order": 259, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 821, + "end_line": 821, + "section": "Checkout Capability > Overview > Warning Presentation", + "block_type": "table_cell", + "page": "specification/shopping/checkout/", + "anchor": "warning-presentation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WARNING-PRESENTATION-12", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: Warning Presentation table: how platforms render warnings", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 342, + "level": "MUST", + "text_digest": "d8320eb452" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 821, + "level": "MUST", + "text_digest": "d8320eb452" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0072", + "text_digest": "63eb9ce1e6", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **MUST** display the warning content to the buyer.", + "normalized": "platforms must display the warning content to the buyer", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 261, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 825, + "end_line": 827, + "section": "Checkout Capability > Overview > Warning Presentation > `notice` (default)", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "notice-default" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-NOTICE-DEFAULT-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 346, + "level": "MUST", + "text_digest": "63eb9ce1e6" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 825, + "level": "MUST", + "text_digest": "63eb9ce1e6" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0073", + "text_digest": "332fc3eb7b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **MAY** render notices in a banner, tray, or toast", + "normalized": "platforms may render notices in a banner, tray, or toast", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 262, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 825, + "end_line": 827, + "section": "Checkout Capability > Overview > Warning Presentation > `notice` (default)", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "notice-default" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-NOTICE-DEFAULT-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 346, + "level": "MAY", + "text_digest": "332fc3eb7b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 825, + "level": "MAY", + "text_digest": "332fc3eb7b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0074", + "text_digest": "bfb5252497", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **MAY** allow the buyer to dismiss them.", + "normalized": "platforms may allow the buyer to dismiss them", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 262, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 825, + "end_line": 827, + "section": "Checkout Capability > Overview > Warning Presentation > `notice` (default)", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "notice-default" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-NOTICE-DEFAULT-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 346, + "level": "MAY", + "text_digest": "bfb5252497" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 825, + "level": "MAY", + "text_digest": "bfb5252497" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0075", + "text_digest": "6f25efb860", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Warnings with `presentation: \"disclosure\"` carry notices — safety warnings, allergen declarations, compliance content, etc. — that **MUST** follow the prescribed rendering contract below.", + "normalized": "warnings with presentation: \"disclosure\" carry notices - safety warnings, allergen declarations, compliance content, etc. - that must follow the prescribed rendering contract below", + "condition": null, + "referenced_fields": [ + "presentation" + ], + "compound_parent": null, + "document_order": 263, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 831, + "end_line": 833, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: rendering contract for platforms", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "rendering contract for platforms" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 352, + "level": "MUST", + "text_digest": "6f25efb860" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 831, + "level": "MUST", + "text_digest": "6f25efb860" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0076", + "text_digest": "06cceec768", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.8, + "clause": "**MUST** display the warning `content` to the buyer.", + "normalized": "must display the warning content to the buyer", + "condition": null, + "referenced_fields": [ + "content" + ], + "compound_parent": "**Platform requirements:**", + "document_order": 265, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 837, + "end_line": 837, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 358, + "level": "MUST", + "text_digest": "06cceec768" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 837, + "level": "MUST", + "text_digest": "06cceec768" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0077", + "text_digest": "ae0c97bc1a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.8, + "clause": "**MUST** display the warning in proximity to the component referenced by `path`, preserving the association between the disclosure and its subject.", + "normalized": "must display the warning in proximity to the component referenced by path, preserving the association between the disclosure and its subject", + "condition": null, + "referenced_fields": [ + "path" + ], + "compound_parent": "**Platform requirements:**", + "document_order": 266, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 838, + "end_line": 841, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 359, + "level": "MUST", + "text_digest": "ae0c97bc1a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 838, + "level": "MUST", + "text_digest": "ae0c97bc1a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0078", + "text_digest": "a1863922cf", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.8, + "clause": "**MUST NOT** hide, collapse, or auto-dismiss the warning.", + "normalized": "must not hide, collapse, or auto-dismiss the warning", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Platform requirements:**", + "document_order": 268, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 842, + "end_line": 842, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 363, + "level": "MUST NOT", + "text_digest": "a1863922cf" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 842, + "level": "MUST NOT", + "text_digest": "a1863922cf" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0079", + "text_digest": "fd7771f63a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.8, + "clause": "**MUST** render `image_url` when present (e.g., warning symbol, energy class label).", + "normalized": "must render image_url when present (e.g., warning symbol, energy class label)", + "condition": "when present (e.g., warning symbol, energy class label)", + "referenced_fields": [ + "image_url" + ], + "compound_parent": "**Platform requirements:**", + "document_order": 269, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 843, + "end_line": 844, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-05", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 364, + "level": "MUST", + "text_digest": "fd7771f63a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 843, + "level": "MUST", + "text_digest": "fd7771f63a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0080", + "text_digest": "820a2f9efe", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.8, + "clause": "**SHOULD** render `url` as a navigable reference link when present.", + "normalized": "should render url as a navigable reference link when present", + "condition": "when present", + "referenced_fields": [ + "url" + ], + "compound_parent": "**Platform requirements:**", + "document_order": 270, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 845, + "end_line": 845, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-06", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 366, + "level": "SHOULD", + "text_digest": "820a2f9efe" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 845, + "level": "SHOULD", + "text_digest": "820a2f9efe" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0081", + "text_digest": "0263f18adb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Warnings with `presentation: \"disclosure\"` **SHOULD** be given rendering priority over notices.", + "normalized": "warnings with presentation: \"disclosure\" should be given rendering priority over notices", + "condition": null, + "referenced_fields": [ + "presentation" + ], + "compound_parent": null, + "document_order": 271, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 847, + "end_line": 848, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-07", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: rendering priority for platforms", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "rendering priority for platforms" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 368, + "level": "SHOULD", + "text_digest": "0263f18adb" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 847, + "level": "SHOULD", + "text_digest": "0263f18adb" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0082", + "text_digest": "489e05ddc3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms that cannot honor the disclosure rendering contract **MUST** escalate to merchant UI via `continue_url` rather than silently downgrading to a notice.", + "normalized": "platforms that cannot honor the disclosure rendering contract must escalate to merchant ui via continue_url rather than silently downgrading to a notice", + "condition": null, + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 272, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 850, + "end_line": 852, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-08", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 371, + "level": "MUST", + "text_digest": "489e05ddc3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 850, + "level": "MUST", + "text_digest": "489e05ddc3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0083", + "text_digest": "beafa21ced", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.8, + "clause": "**MUST** set `presentation: \"disclosure\"` when the warning content must be displayed alongside a specific component and must not be hidden or auto-dismissed.", + "normalized": "must set presentation: \"disclosure\" when the warning content must be displayed alongside a specific component and must not be hidden or auto-dismissed", + "condition": "when the warning content must be displayed alongside a specific component and must not be hidden or auto-dismissed", + "referenced_fields": [ + "presentation" + ], + "compound_parent": "**Business requirements:**", + "document_order": 274, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 856, + "end_line": 858, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-09", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 377, + "level": "MUST", + "text_digest": "beafa21ced" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 856, + "level": "MUST", + "text_digest": "beafa21ced" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0084", + "text_digest": "0d63274715", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.8, + "clause": "**SHOULD** use the `path` field to associate disclosures with the relevant component in the response.", + "normalized": "should use the path field to associate disclosures with the relevant component in the response", + "condition": null, + "referenced_fields": [ + "path" + ], + "compound_parent": "**Business requirements:**", + "document_order": 275, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 859, + "end_line": 860, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-10", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 380, + "level": "SHOULD", + "text_digest": "0d63274715" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 859, + "level": "SHOULD", + "text_digest": "0d63274715" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0085", + "text_digest": "53c2decc92", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.8, + "clause": "**SHOULD** provide a `code` that identifies the disclosure category (e.g., `prop65`, `allergens`, `energy_label`).", + "normalized": "should provide a code that identifies the disclosure category (e.g., prop65, allergens, energy_label)", + "condition": null, + "referenced_fields": [ + "allergens", + "code", + "energy_label", + "prop65" + ], + "compound_parent": "**Business requirements:**", + "document_order": 276, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 861, + "end_line": 864, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-11", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 382, + "level": "SHOULD", + "text_digest": "53c2decc92" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 861, + "level": "SHOULD", + "text_digest": "53c2decc92" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0086", + "text_digest": "2c7e59d4d5", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.8, + "clause": "When the disclosure renders a structured `policies[]` entry, the `code` **MUST** equal that policy's `type` to link the two (see [Policies](../../overview/index.md#policies)).", + "normalized": "when the disclosure renders a structured policies[] entry, the code must equal that policy's type to link the two (see policies)", + "condition": "When the disclosure renders a structured `policies[]` entry", + "referenced_fields": [ + "code", + "policies[]", + "type" + ], + "compound_parent": "**Business requirements:**", + "document_order": 277, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 861, + "end_line": 864, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-12", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 861, + "level": "MUST", + "text_digest": "2c7e59d4d5" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0087", + "text_digest": "05d6c52b57", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.8, + "clause": "**SHOULD** provide `image_url` when the disclosure has an associated visual element (e.g., warning symbol, energy class label).", + "normalized": "should provide image_url when the disclosure has an associated visual element (e.g., warning symbol, energy class label)", + "condition": "when the disclosure has an associated visual element (e.g., warning symbol, energy class label)", + "referenced_fields": [ + "image_url" + ], + "compound_parent": "**Business requirements:**", + "document_order": 278, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 865, + "end_line": 866, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-13", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 384, + "level": "SHOULD", + "text_digest": "05d6c52b57" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 865, + "level": "SHOULD", + "text_digest": "05d6c52b57" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0088", + "text_digest": "1017c13bf3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.8, + "clause": "**SHOULD** provide `url` when a reference link is available for the buyer to learn more.", + "normalized": "should provide url when a reference link is available for the buyer to learn more", + "condition": "when a reference link is available for the buyer to learn more", + "referenced_fields": [ + "url" + ], + "compound_parent": "**Business requirements:**", + "document_order": 279, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 867, + "end_line": 868, + "section": "Checkout Capability > Overview > Warning Presentation > `disclosure`", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "disclosure" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-14", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 386, + "level": "SHOULD", + "text_digest": "1017c13bf3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 867, + "level": "SHOULD", + "text_digest": "1017c13bf3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0089", + "text_digest": "a0fa76b0d2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When affirmative buyer acknowledgment or authorization is also required, the business **MAY** combine the disclosure with the escalation mechanisms described in the [Checkout Status Lifecycle](#checkout-status-lifecycle) to ensure the appropriate buyer input is obtained.", + "normalized": "when affirmative buyer acknowledgment or authorization is also required, the business may combine the disclosure with the escalation mechanisms described in the checkout status lifecycle to ensure the appropriate buyer input is obtained", + "condition": "When affirmative buyer acknowledgment or authorization is also required", + "referenced_fields": [], + "compound_parent": null, + "document_order": 281, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 872, + "end_line": 877, + "section": "Checkout Capability > Overview > Warning Presentation > Disclosure and Acknowledgment", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "disclosure-and-acknowledgment" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-DISCLOSURE-AND-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 391, + "level": "MAY", + "text_digest": "a0fa76b0d2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 872, + "level": "MAY", + "text_digest": "a0fa76b0d2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0090", + "text_digest": "db543e2f62", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **SHOULD** use buyer-provided data (`context` and other inputs) and product attributes to resolve jurisdiction-specific requirements.", + "normalized": "businesses should use buyer-provided data (context and other inputs) and product attributes to resolve jurisdiction-specific requirements", + "condition": null, + "referenced_fields": [ + "context" + ], + "compound_parent": null, + "document_order": 283, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 881, + "end_line": 886, + "section": "Checkout Capability > Overview > Warning Presentation > Jurisdiction and Applicability", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "jurisdiction-and-applicability" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-JURISDICTION-AND-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 400, + "level": "SHOULD", + "text_digest": "db543e2f62" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 881, + "level": "SHOULD", + "text_digest": "db543e2f62" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0091", + "text_digest": "e583c00f08", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MUST** provide `continue_url` when returning `status` = `requires_escalation`.", + "normalized": "businesses must provide continue_url when returning status = requires_escalation", + "condition": "when returning `status` = `requires_escalation`", + "referenced_fields": [ + "continue_url", + "requires_escalation", + "status" + ], + "compound_parent": null, + "document_order": 288, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 949, + "end_line": 953, + "section": "Checkout Capability > Continue URL > Availability", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "availability" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-AVAILABILITY-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 201, + "level": "MUST", + "text_digest": "e583c00f08" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 206, + "level": "MUST", + "text_digest": "e583c00f08" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 461, + "level": "MUST", + "text_digest": "e583c00f08" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 949, + "level": "MUST", + "text_digest": "e583c00f08" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0092", + "text_digest": "a625c88b45", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "For all other non-terminal statuses (`incomplete`, `ready_for_complete`, `complete_in_progress`), businesses **SHOULD** provide `continue_url`.", + "normalized": "for all other non-terminal statuses (incomplete, ready_for_complete, complete_in_progress), businesses should provide continue_url", + "condition": null, + "referenced_fields": [ + "complete_in_progress", + "continue_url", + "incomplete", + "ready_for_complete" + ], + "compound_parent": null, + "document_order": 289, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 949, + "end_line": 953, + "section": "Checkout Capability > Continue URL > Availability", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "availability" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-AVAILABILITY-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 201, + "level": "SHOULD", + "text_digest": "a625c88b45" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 206, + "level": "SHOULD", + "text_digest": "a625c88b45" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 461, + "level": "SHOULD", + "text_digest": "a625c88b45" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 949, + "level": "SHOULD", + "text_digest": "a625c88b45" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0093", + "text_digest": "ec3bac66a2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "For terminal states (`completed`, `canceled`), `continue_url` **SHOULD** be omitted.", + "normalized": "for terminal states (completed, canceled), continue_url should be omitted", + "condition": null, + "referenced_fields": [ + "canceled", + "completed", + "continue_url" + ], + "compound_parent": null, + "document_order": 290, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 949, + "end_line": 953, + "section": "Checkout Capability > Continue URL > Availability", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "availability" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-AVAILABILITY-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 201, + "level": "SHOULD", + "text_digest": "ec3bac66a2" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 206, + "level": "SHOULD", + "text_digest": "ec3bac66a2" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 461, + "level": "SHOULD", + "text_digest": "ec3bac66a2" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 949, + "level": "SHOULD", + "text_digest": "ec3bac66a2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0094", + "text_digest": "e6f81fd0dd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The `continue_url` **MUST** be an absolute HTTPS URL", + "normalized": "the continue_url must be an absolute https url", + "condition": null, + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 291, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 957, + "end_line": 959, + "section": "Checkout Capability > Continue URL > Format", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "format" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-FORMAT-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 209, + "level": "MUST", + "text_digest": "e6f81fd0dd" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 214, + "level": "MUST", + "text_digest": "e6f81fd0dd" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 469, + "level": "MUST", + "text_digest": "e6f81fd0dd" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 957, + "level": "MUST", + "text_digest": "e6f81fd0dd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0095", + "text_digest": "a1b795b70e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The `continue_url` **SHOULD** preserve checkout state for seamless handoff.", + "normalized": "the continue_url should preserve checkout state for seamless handoff", + "condition": null, + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 291, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 957, + "end_line": 959, + "section": "Checkout Capability > Continue URL > Format", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "format" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-FORMAT-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: needs a browser handoff; not visible in API responses", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "needs a browser handoff; not visible in API responses" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 209, + "level": "SHOULD", + "text_digest": "a1b795b70e" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 214, + "level": "SHOULD", + "text_digest": "a1b795b70e" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 469, + "level": "SHOULD", + "text_digest": "a1b795b70e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 957, + "level": "SHOULD", + "text_digest": "a1b795b70e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0096", + "text_digest": "5c90286075", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MAY** implement state preservation using either approach:", + "normalized": "businesses may implement state preservation using either approach", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 292, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 957, + "end_line": 959, + "section": "Checkout Capability > Continue URL > Format", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "format" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-FORMAT-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 209, + "level": "MAY", + "text_digest": "5c90286075" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 214, + "level": "MAY", + "text_digest": "5c90286075" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 469, + "level": "MAY", + "text_digest": "5c90286075" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 957, + "level": "MAY", + "text_digest": "5c90286075" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0097", + "text_digest": "1717dcf0e4", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **SHOULD** implement support for this format to facilitate checkout handoff and accelerated entry—for example, a platform can prefill checkout state when initiating a buy-now flow.", + "normalized": "businesses should implement support for this format to facilitate checkout handoff and accelerated entry-for example, a platform can prefill checkout state when initiating a buy-now flow", + "condition": "when initiating a buy-now flow", + "referenced_fields": [], + "compound_parent": null, + "document_order": 298, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 975, + "end_line": 978, + "section": "Checkout Capability > Continue URL > Format > Checkout Permalink", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "checkout-permalink" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-CHECKOUT-PERMALINK-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 227, + "level": "SHOULD", + "text_digest": "1717dcf0e4" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 232, + "level": "SHOULD", + "text_digest": "1717dcf0e4" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 487, + "level": "SHOULD", + "text_digest": "1717dcf0e4" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 975, + "level": "SHOULD", + "text_digest": "1717dcf0e4" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0098", + "text_digest": "404be9b6a9", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "**MAY** engage an agent to facilitate the checkout session (e.g. add items to the checkout session, select fulfillment address).", + "normalized": "may engage an agent to facilitate the checkout session (e.g. add items to the checkout session, select fulfillment address)", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 306, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1002, + "end_line": 1006, + "section": "Checkout Capability > Guidelines > Platform", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "platform" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-PLATFORM-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 242, + "level": "MAY", + "text_digest": "404be9b6a9" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 247, + "level": "MAY", + "text_digest": "404be9b6a9" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 514, + "level": "MAY", + "text_digest": "404be9b6a9" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1002, + "level": "MAY", + "text_digest": "404be9b6a9" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0099", + "text_digest": "5bfe027f42", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "**MAY** send the user from the trusted, deterministic UI back to the agent at any time.", + "normalized": "may send the user from the trusted, deterministic ui back to the agent at any time", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 308, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1007, + "end_line": 1009, + "section": "Checkout Capability > Guidelines > Platform", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "platform" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-PLATFORM-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 246, + "level": "MAY", + "text_digest": "5bfe027f42" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 252, + "level": "MAY", + "text_digest": "5bfe027f42" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 519, + "level": "MAY", + "text_digest": "5bfe027f42" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1007, + "level": "MAY", + "text_digest": "5bfe027f42" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0100", + "text_digest": "6bb1d43d30", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "**MAY** provide agent context when the platform indicates that the request was done by an agent.", + "normalized": "may provide agent context when the platform indicates that the request was done by an agent", + "condition": "when the platform indicates that the request was done by an agent", + "referenced_fields": [], + "compound_parent": null, + "document_order": 310, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1010, + "end_line": 1011, + "section": "Checkout Capability > Guidelines > Platform", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "platform" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-PLATFORM-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 249, + "level": "MAY", + "text_digest": "6bb1d43d30" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 255, + "level": "MAY", + "text_digest": "6bb1d43d30" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 522, + "level": "MAY", + "text_digest": "6bb1d43d30" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1010, + "level": "MAY", + "text_digest": "6bb1d43d30" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0101", + "text_digest": "d0db3bab09", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "**MUST** use `continue_url` when checkout status is `requires_escalation`.", + "normalized": "must use continue_url when checkout status is requires_escalation", + "condition": "when checkout status is `requires_escalation`", + "referenced_fields": [ + "continue_url", + "requires_escalation" + ], + "compound_parent": null, + "document_order": 311, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1012, + "end_line": 1012, + "section": "Checkout Capability > Guidelines > Platform", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "platform" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-PLATFORM-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 251, + "level": "MUST", + "text_digest": "d0db3bab09" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 257, + "level": "MUST", + "text_digest": "d0db3bab09" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 524, + "level": "MUST", + "text_digest": "d0db3bab09" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1012, + "level": "MUST", + "text_digest": "d0db3bab09" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0102", + "text_digest": "50c0cd861a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "**MAY** use `continue_url` to hand off to business UI in other situations.", + "normalized": "may use continue_url to hand off to business ui in other situations", + "condition": null, + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 312, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1013, + "end_line": 1013, + "section": "Checkout Capability > Guidelines > Platform", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "platform" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-PLATFORM-05", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 252, + "level": "MAY", + "text_digest": "50c0cd861a" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 258, + "level": "MAY", + "text_digest": "50c0cd861a" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 525, + "level": "MAY", + "text_digest": "50c0cd861a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1013, + "level": "MAY", + "text_digest": "50c0cd861a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0103", + "text_digest": "195cd330b6", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "When performing handoff, **SHOULD** prefer business-provided `continue_url` over platform-constructed checkout permalinks.", + "normalized": "when performing handoff, should prefer business-provided continue_url over platform-constructed checkout permalinks", + "condition": "When performing handoff", + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 313, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1014, + "end_line": 1015, + "section": "Checkout Capability > Guidelines > Platform", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "platform" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-PLATFORM-06", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 253, + "level": "SHOULD", + "text_digest": "195cd330b6" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 259, + "level": "SHOULD", + "text_digest": "195cd330b6" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 526, + "level": "SHOULD", + "text_digest": "195cd330b6" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1014, + "level": "SHOULD", + "text_digest": "195cd330b6" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0104", + "text_digest": "30d3516026", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**MUST** send a confirmation email after the checkout has been completed.", + "normalized": "must send a confirmation email after the checkout has been completed", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 314, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1019, + "end_line": 1019, + "section": "Checkout Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-BUSINESS-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: out-of-band side effect (email delivery); not observable in UCP HTTP responses", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "out-of-band side effect (email delivery); not observable in UCP HTTP responses" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 258, + "level": "MUST", + "text_digest": "30d3516026" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 264, + "level": "MUST", + "text_digest": "30d3516026" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 531, + "level": "MUST", + "text_digest": "30d3516026" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1019, + "level": "MUST", + "text_digest": "30d3516026" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0105", + "text_digest": "ab9070f00a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**SHOULD** provide accurate error messages.", + "normalized": "should provide accurate error messages", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 315, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1020, + "end_line": 1020, + "section": "Checkout Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-BUSINESS-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 259, + "level": "SHOULD", + "text_digest": "ab9070f00a" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 265, + "level": "SHOULD", + "text_digest": "ab9070f00a" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 532, + "level": "SHOULD", + "text_digest": "ab9070f00a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1020, + "level": "SHOULD", + "text_digest": "ab9070f00a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0106", + "text_digest": "adbf81349f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "Logic handling the checkout sessions **MUST** be deterministic.", + "normalized": "logic handling the checkout sessions must be deterministic", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 316, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1021, + "end_line": 1021, + "section": "Checkout Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-BUSINESS-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: architectural principle (deterministic server logic rather than generative computation); observable wire invariants are covered by the totals, line-pricing, and idempotency rules", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "architectural principle (deterministic server logic rather than generative computation); observable wire invariants are covered by the totals, line-pricing, and idempotency rules" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 260, + "level": "MUST", + "text_digest": "adbf81349f" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 266, + "level": "MUST", + "text_digest": "adbf81349f" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 533, + "level": "MUST", + "text_digest": "adbf81349f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1021, + "level": "MUST", + "text_digest": "adbf81349f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0107", + "text_digest": "59ce9514a8", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**MUST** provide `continue_url` when returning `status` = `requires_escalation`.", + "normalized": "must provide continue_url when returning status = requires_escalation", + "condition": "when returning `status` = `requires_escalation`", + "referenced_fields": [ + "continue_url", + "requires_escalation", + "status" + ], + "compound_parent": null, + "document_order": 317, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1022, + "end_line": 1023, + "section": "Checkout Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-BUSINESS-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 261, + "level": "MUST", + "text_digest": "59ce9514a8" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 267, + "level": "MUST", + "text_digest": "59ce9514a8" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 534, + "level": "MUST", + "text_digest": "59ce9514a8" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1022, + "level": "MUST", + "text_digest": "59ce9514a8" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0108", + "text_digest": "43a4121d2d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**MUST** include at least one message with `severity` of `requires_buyer_input` or `requires_buyer_review` when returning `status` = `requires_escalation`.", + "normalized": "must include at least one message with severity of requires_buyer_input or requires_buyer_review when returning status = requires_escalation", + "condition": "when returning `status` = `requires_escalation`", + "referenced_fields": [ + "requires_buyer_input", + "requires_buyer_review", + "requires_escalation", + "severity", + "status" + ], + "compound_parent": null, + "document_order": 318, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1024, + "end_line": 1026, + "section": "Checkout Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-BUSINESS-05", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 536, + "level": "MUST", + "text_digest": "43a4121d2d" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1024, + "level": "MUST", + "text_digest": "43a4121d2d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0109", + "text_digest": "456e8a756f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**SHOULD** provide `continue_url` in all non-terminal checkout responses.", + "normalized": "should provide continue_url in all non-terminal checkout responses", + "condition": null, + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 319, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1027, + "end_line": 1027, + "section": "Checkout Capability > Guidelines > Business", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "business" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-BUSINESS-06", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 265, + "level": "SHOULD", + "text_digest": "456e8a756f" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 271, + "level": "SHOULD", + "text_digest": "456e8a756f" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 539, + "level": "SHOULD", + "text_digest": "456e8a756f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1027, + "level": "SHOULD", + "text_digest": "456e8a756f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0110", + "text_digest": "04933d86f1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "To minimize discrepancies and a streamlined user experience, product data (price/title etc.) provided by the business through the feeds **SHOULD** match the actual attributes returned in the response.", + "normalized": "to minimize discrepancies and a streamlined user experience, product data (price/title etc.) provided by the business through the feeds should match the actual attributes returned in the response", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 336, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1052, + "end_line": 1054, + "section": "Checkout Capability > Operations > Create Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "create-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-CREATE-CHECKOUT-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 290, + "level": "SHOULD", + "text_digest": "04933d86f1" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 296, + "level": "SHOULD", + "text_digest": "04933d86f1" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 564, + "level": "SHOULD", + "text_digest": "04933d86f1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1052, + "level": "SHOULD", + "text_digest": "04933d86f1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0111", + "text_digest": "bac6d12327", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The platform is **REQUIRED** to send the entire checkout resource containing any data updates to write-only data fields.", + "normalized": "the platform is required to send the entire checkout resource containing any data updates to write-only data fields", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 346, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1078, + "end_line": 1084, + "section": "Checkout Capability > Operations > Update Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "update-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-UPDATE-CHECKOUT-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 311, + "level": "MUST", + "text_digest": "bac6d12327" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 317, + "level": "MUST", + "text_digest": "bac6d12327" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 585, + "level": "MUST", + "text_digest": "bac6d12327" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1078, + "level": "MUST", + "text_digest": "bac6d12327" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0112", + "text_digest": "2d86535f99", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST NOT** use Complete Checkout to poll or resume accepted processing.", + "normalized": "the platform must not use complete checkout to poll or resume accepted processing", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 358, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "end_line": 1118, + "section": "Checkout Capability > Operations > Complete Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "complete-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-COMPLETE-CHECKOUT-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "level": "MUST NOT", + "text_digest": "2d86535f99" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0113", + "text_digest": "9727e007fa", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "If the Platform does not receive a response to Complete Checkout, it **SHOULD** use Get Checkout with bounded backoff to obtain the current state", + "normalized": "if the platform does not receive a response to complete checkout, it should use get checkout with bounded backoff to obtain the current state", + "condition": "If the Platform does not receive a response to Complete Checkout", + "referenced_fields": [], + "compound_parent": null, + "document_order": 359, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "end_line": 1118, + "section": "Checkout Capability > Operations > Complete Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "complete-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-COMPLETE-CHECKOUT-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "level": "SHOULD", + "text_digest": "9727e007fa" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0114", + "text_digest": "1c7ec12253", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "If the Platform does not receive a response to Complete Checkout, it **MUST** stop at `expires_at`.", + "normalized": "if the platform does not receive a response to complete checkout, it must stop at expires_at", + "condition": "If the Platform does not receive a response to Complete Checkout", + "referenced_fields": [ + "expires_at" + ], + "compound_parent": null, + "document_order": 359, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "end_line": 1118, + "section": "Checkout Capability > Operations > Complete Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "complete-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-COMPLETE-CHECKOUT-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "level": "MUST", + "text_digest": "1c7ec12253" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0115", + "text_digest": "5ba0cdb896", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Only if Get Checkout still does not establish whether the Business processed the original request, the Platform **MAY** submit the identical original Complete Checkout request again with the same idempotency key.", + "normalized": "only if get checkout still does not establish whether the business processed the original request, the platform may submit the identical original complete checkout request again with the same idempotency key", + "condition": "if Get Checkout still does not establish whether the Business processed the original request", + "referenced_fields": [], + "compound_parent": null, + "document_order": 360, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "end_line": 1118, + "section": "Checkout Capability > Operations > Complete Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "complete-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-COMPLETE-CHECKOUT-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "level": "MAY", + "text_digest": "5ba0cdb896" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0116", + "text_digest": "47be3f62c8", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST NOT** use a new idempotency key for that retry.", + "normalized": "the platform must not use a new idempotency key for that retry", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 361, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "end_line": 1118, + "section": "Checkout Capability > Operations > Complete Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "complete-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-COMPLETE-CHECKOUT-05", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "level": "MUST NOT", + "text_digest": "47be3f62c8" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0117", + "text_digest": "0c5c2c4998", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "A genuinely new Complete Checkout operation after the Checkout returns to `ready_for_complete` **MUST** use a fresh idempotency key, even if the payload is unchanged.", + "normalized": "a genuinely new complete checkout operation after the checkout returns to ready_for_complete must use a fresh idempotency key, even if the payload is unchanged", + "condition": "if the payload is unchanged", + "referenced_fields": [ + "ready_for_complete" + ], + "compound_parent": null, + "document_order": 362, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "end_line": 1118, + "section": "Checkout Capability > Operations > Complete Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "complete-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-COMPLETE-CHECKOUT-06", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: the platform chooses idempotency keys", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "the platform chooses idempotency keys" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1109, + "level": "MUST", + "text_digest": "0c5c2c4998" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0118", + "text_digest": "56dd9d5db0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "At the time of order persistence, fields from `Checkout` **MAY** be used to construct the order representation (i.e. information like `line_items`, `fulfillment` will be used to create the initial order representation).", + "normalized": "at the time of order persistence, fields from checkout may be used to construct the order representation (i.e. information like line_items, fulfillment will be used to create the initial order representation)", + "condition": null, + "referenced_fields": [ + "fulfillment", + "line_items" + ], + "compound_parent": null, + "document_order": 363, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1120, + "end_line": 1122, + "section": "Checkout Capability > Operations > Complete Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "complete-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-COMPLETE-CHECKOUT-07", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: describes how the business may build the order; nothing a test can fail", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "describes how the business may build the order; nothing a test can fail" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 320, + "level": "MAY", + "text_digest": "56dd9d5db0" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 326, + "level": "MAY", + "text_digest": "56dd9d5db0" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 594, + "level": "MAY", + "text_digest": "56dd9d5db0" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1120, + "level": "MAY", + "text_digest": "56dd9d5db0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0119", + "text_digest": "6f0756c2eb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "If the checkout session cannot be canceled (e.g. checkout session is already canceled or completed), then businesses **SHOULD** send back an error indicating the operation is not allowed.", + "normalized": "if the checkout session cannot be canceled (e.g. checkout session is already canceled or completed), then businesses should send back an error indicating the operation is not allowed", + "condition": "If the checkout session cannot be canceled (e.g. checkout session is already canceled or completed)", + "referenced_fields": [], + "compound_parent": null, + "document_order": 367, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1131, + "end_line": 1135, + "section": "Checkout Capability > Operations > Cancel Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "cancel-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-CANCEL-CHECKOUT-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 336, + "level": "SHOULD", + "text_digest": "6f0756c2eb" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 342, + "level": "SHOULD", + "text_digest": "6f0756c2eb" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 610, + "level": "SHOULD", + "text_digest": "6f0756c2eb" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1131, + "level": "SHOULD", + "text_digest": "6f0756c2eb" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0120", + "text_digest": "1929627a42", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Any checkout session with a status that is not equal to `completed` or `canceled` **SHOULD** be cancelable.", + "normalized": "any checkout session with a status that is not equal to completed or canceled should be cancelable", + "condition": null, + "referenced_fields": [ + "canceled", + "completed" + ], + "compound_parent": null, + "document_order": 368, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1131, + "end_line": 1135, + "section": "Checkout Capability > Operations > Cancel Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "cancel-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-CANCEL-CHECKOUT-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: cancel succeeds", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: cancel succeeds" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 336, + "level": "SHOULD", + "text_digest": "1929627a42" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 342, + "level": "SHOULD", + "text_digest": "1929627a42" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 610, + "level": "SHOULD", + "text_digest": "1929627a42" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1131, + "level": "SHOULD", + "text_digest": "1929627a42" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0121", + "text_digest": "35b444ee45", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses SHOULD use these values when verified inputs (e.g., shipping address) are absent", + "normalized": "businesses should use these values when verified inputs (e.g., shipping address) are absent", + "condition": "when verified inputs (e.g., shipping address) are absent", + "referenced_fields": [], + "compound_parent": null, + "document_order": 381, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1157, + "end_line": 1162, + "section": "Checkout Capability > Entities > Context", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-CONTEXT-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible in results when no address is given (weakly)", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in results when no address is given (weakly)" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 636, + "level": "SHOULD", + "text_digest": "35b444ee45" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1157, + "level": "SHOULD", + "text_digest": "35b444ee45" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0122", + "text_digest": "e137bb0b98", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses MAY ignore or down-rank them if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls).", + "normalized": "businesses may ignore or down-rank them if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls)", + "condition": "if inconsistent with higher-confidence signals (authenticated account, risk detection) or regulatory constraints (export controls)", + "referenced_fields": [], + "compound_parent": null, + "document_order": 381, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1157, + "end_line": 1162, + "section": "Checkout Capability > Entities > Context", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-CONTEXT-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: an internal ranking decision; nothing visible to check", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "an internal ranking decision; nothing visible to check" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 636, + "level": "MAY", + "text_digest": "e137bb0b98" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1157, + "level": "MAY", + "text_digest": "e137bb0b98" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0123", + "text_digest": "d647a85835", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Eligibility and policy enforcement MUST occur at checkout time using binding transaction data.", + "normalized": "eligibility and policy enforcement must occur at checkout time using binding transaction data", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 382, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1157, + "end_line": 1162, + "section": "Checkout Capability > Entities > Context", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "context" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-CONTEXT-03", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: about where the business enforces policy; no specific response to check", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "about where the business enforces policy; no specific response to check" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 636, + "level": "MUST", + "text_digest": "d647a85835" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1157, + "level": "MUST", + "text_digest": "d647a85835" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0124", + "text_digest": "916a488164", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "BUYER", + "actor_confidence": 0.9, + "clause": "Unlike `context` (buyer-asserted preferences) and `buyer` (self-reported identity), signal values MUST NOT be buyer-asserted claims — platforms provide signals based on direct observation or by relaying independently verifiable third-party attestations.", + "normalized": "unlike context (buyer-asserted preferences) and buyer (self-reported identity), signal values must not be buyer-asserted claims - platforms provide signals based on direct observation or by relaying independently verifiable third-party attestations", + "condition": null, + "referenced_fields": [ + "buyer", + "context" + ], + "compound_parent": null, + "document_order": 385, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1168, + "end_line": 1174, + "section": "Checkout Capability > Entities > Signals", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "signals" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-SIGNALS-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: platforms provide signals (the extractor read 'buyer')", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "platforms provide signals (the extractor read 'buyer')" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 647, + "level": "MUST NOT", + "text_digest": "916a488164" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1168, + "level": "MUST NOT", + "text_digest": "916a488164" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0125", + "text_digest": "711f3836a0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **SHOULD** provide all relevant links for the transaction.", + "normalized": "businesses should provide all relevant links for the transaction", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 398, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1221, + "end_line": 1222, + "section": "Checkout Capability > Entities > Link > Well-Known Link Types", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "well-known-link-types" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WELL-KNOWN-LINK-TYPES-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 402, + "level": "SHOULD", + "text_digest": "711f3836a0" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 413, + "level": "SHOULD", + "text_digest": "711f3836a0" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 704, + "level": "SHOULD", + "text_digest": "711f3836a0" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1221, + "level": "SHOULD", + "text_digest": "711f3836a0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0126", + "text_digest": "9616b961a3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MAY** define custom types for domain-specific needs.", + "normalized": "businesses may define custom types for domain-specific needs", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 410, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1232, + "end_line": 1234, + "section": "Checkout Capability > Entities > Link > Well-Known Link Types", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "well-known-link-types" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WELL-KNOWN-LINK-TYPES-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 413, + "level": "MAY", + "text_digest": "9616b961a3" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 424, + "level": "MAY", + "text_digest": "9616b961a3" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 715, + "level": "MAY", + "text_digest": "9616b961a3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1232, + "level": "MAY", + "text_digest": "9616b961a3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0127", + "text_digest": "85bc46fdb7", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **SHOULD** handle unknown types gracefully by displaying them using the `title` field or omitting them.", + "normalized": "platforms should handle unknown types gracefully by displaying them using the title field or omitting them", + "condition": null, + "referenced_fields": [ + "title" + ], + "compound_parent": null, + "document_order": 411, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1232, + "end_line": 1234, + "section": "Checkout Capability > Entities > Link > Well-Known Link Types", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "well-known-link-types" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WELL-KNOWN-LINK-TYPES-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout.md", + "start_line": 413, + "level": "SHOULD", + "text_digest": "85bc46fdb7" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout.md", + "start_line": 424, + "level": "SHOULD", + "text_digest": "85bc46fdb7" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 715, + "level": "SHOULD", + "text_digest": "85bc46fdb7" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1232, + "level": "SHOULD", + "text_digest": "85bc46fdb7" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0128", + "text_digest": "633738379e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms MUST render all top-level entries in the order provided:", + "normalized": "platforms must render all top-level entries in the order provided", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 428, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1296, + "end_line": 1296, + "section": "Checkout Capability > Entities > Total > Rendering Contract", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "rendering-contract" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-RENDERING-CONTRACT-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 770, + "level": "MUST", + "text_digest": "633738379e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1296, + "level": "MUST", + "text_digest": "633738379e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0129", + "text_digest": "9686f34d66", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms MAY render sub-lines as supplementary detail:", + "normalized": "platforms may render sub-lines as supplementary detail", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 429, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1303, + "end_line": 1303, + "section": "Checkout Capability > Entities > Total > Rendering Contract", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "rendering-contract" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-RENDERING-CONTRACT-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 777, + "level": "MAY", + "text_digest": "9686f34d66" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1303, + "level": "MAY", + "text_digest": "9686f34d66" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0130", + "text_digest": "ed6e5e1a5e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms MUST NOT interpret, filter, reorder, aggregate, or apply display logic of their own.", + "normalized": "platforms must not interpret, filter, reorder, aggregate, or apply display logic of their own", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 430, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1313, + "end_line": 1314, + "section": "Checkout Capability > Entities > Total > Rendering Contract", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "rendering-contract" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-RENDERING-CONTRACT-03", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 787, + "level": "MUST NOT", + "text_digest": "ed6e5e1a5e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1313, + "level": "MUST NOT", + "text_digest": "ed6e5e1a5e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0131", + "text_digest": "78eb4e97bf", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms SHOULD use `display_text` when provided.", + "normalized": "platforms should use display_text when provided", + "condition": "when provided", + "referenced_fields": [ + "display_text" + ], + "compound_parent": "Invariants of `totals[]`:", + "document_order": 433, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1318, + "end_line": 1320, + "section": "Checkout Capability > Entities > Total > Rendering Contract", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "rendering-contract" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-RENDERING-CONTRACT-04", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 792, + "level": "SHOULD", + "text_digest": "78eb4e97bf" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1318, + "level": "SHOULD", + "text_digest": "78eb4e97bf" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0132", + "text_digest": "debd639454", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Well-known types have default display labels as fallback (see table below); unknown types MUST include `display_text`.", + "normalized": "well-known types have default display labels as fallback (see table below); unknown types must include display_text", + "condition": null, + "referenced_fields": [ + "display_text" + ], + "compound_parent": "Invariants of `totals[]`:", + "document_order": 434, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1318, + "end_line": 1320, + "section": "Checkout Capability > Entities > Total > Rendering Contract", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "rendering-contract" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-RENDERING-CONTRACT-05", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: totals content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 792, + "level": "MUST", + "text_digest": "debd639454" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1318, + "level": "MUST", + "text_digest": "debd639454" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0133", + "text_digest": "d725369b04", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Exactly one `type: \"subtotal\"` MUST be present.", + "normalized": "exactly one type: \"subtotal\" must be present", + "condition": null, + "referenced_fields": [ + "type" + ], + "compound_parent": "Invariants of `totals[]`:", + "document_order": 437, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1323, + "end_line": 1323, + "section": "Checkout Capability > Entities > Total > Rendering Contract", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "rendering-contract" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-RENDERING-CONTRACT-06", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: totals content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 797, + "level": "MUST", + "text_digest": "d725369b04" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1323, + "level": "MUST", + "text_digest": "d725369b04" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0134", + "text_digest": "749321cc43", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Exactly one `type: \"total\"` MUST be present.", + "normalized": "exactly one type: \"total\" must be present", + "condition": null, + "referenced_fields": [ + "type" + ], + "compound_parent": "Invariants of `totals[]`:", + "document_order": 438, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1324, + "end_line": 1324, + "section": "Checkout Capability > Entities > Total > Rendering Contract", + "block_type": "list_item", + "page": "specification/shopping/checkout/", + "anchor": "rendering-contract" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-RENDERING-CONTRACT-07", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: totals content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 798, + "level": "MUST", + "text_digest": "749321cc43" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1324, + "level": "MUST", + "text_digest": "749321cc43" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0135", + "text_digest": "bcc53c3234", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms MUST NOT substitute their own computed totals for the business's values.", + "normalized": "platforms must not substitute their own computed totals for the business's values", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 439, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1328, + "end_line": 1329, + "section": "Checkout Capability > Entities > Total > Verification", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "verification" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-VERIFICATION-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 802, + "level": "MUST NOT", + "text_digest": "bcc53c3234" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1328, + "level": "MUST NOT", + "text_digest": "bcc53c3234" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0136", + "text_digest": "8771b7a275", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms MAY verify the provided totals:", + "normalized": "platforms may verify the provided totals", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 440, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1328, + "end_line": 1329, + "section": "Checkout Capability > Entities > Total > Verification", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "verification" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-VERIFICATION-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 802, + "level": "MAY", + "text_digest": "8771b7a275" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1328, + "level": "MAY", + "text_digest": "8771b7a275" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0137", + "text_digest": "287b81954f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "If the computed sum does not match the `type: \"total\"` entry, the platform MUST NOT alter the rendered output — the business's presented totals are authoritative for display.", + "normalized": "if the computed sum does not match the type: \"total\" entry, the platform must not alter the rendered output - the business's presented totals are authoritative for display", + "condition": "If the computed sum does not match the `type: \"total\"` entry", + "referenced_fields": [ + "type" + ], + "compound_parent": null, + "document_order": 441, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1335, + "end_line": 1339, + "section": "Checkout Capability > Entities > Total > Verification", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "verification" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-VERIFICATION-03", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 809, + "level": "MUST NOT", + "text_digest": "287b81954f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1335, + "level": "MUST NOT", + "text_digest": "287b81954f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0138", + "text_digest": "594b999c87", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "However, platforms MUST NOT autonomously complete a checkout with mismatched totals.", + "normalized": "however, platforms must not autonomously complete a checkout with mismatched totals", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 442, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1335, + "end_line": 1339, + "section": "Checkout Capability > Entities > Total > Verification", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "verification" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-VERIFICATION-04", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 809, + "level": "MUST NOT", + "text_digest": "594b999c87" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1335, + "level": "MUST NOT", + "text_digest": "594b999c87" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0139", + "text_digest": "b43edb9f37", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms SHOULD reject the checkout or escalate and ask for buyer review via `continue_url`.", + "normalized": "platforms should reject the checkout or escalate and ask for buyer review via continue_url", + "condition": null, + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 443, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1335, + "end_line": 1339, + "section": "Checkout Capability > Entities > Total > Verification", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "verification" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-VERIFICATION-05", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 809, + "level": "SHOULD", + "text_digest": "b43edb9f37" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1335, + "level": "SHOULD", + "text_digest": "b43edb9f37" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0140", + "text_digest": "67b450f295", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "When `display_text` is provided, platforms MUST use it.", + "normalized": "when display_text is provided, platforms must use it", + "condition": "When `display_text` is provided", + "referenced_fields": [ + "display_text" + ], + "compound_parent": null, + "document_order": 465, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1353, + "end_line": 1357, + "section": "Checkout Capability > Entities > Total > Well-Known Types", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "well-known-types" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WELL-KNOWN-TYPES-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 827, + "level": "MUST", + "text_digest": "67b450f295" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1353, + "level": "MUST", + "text_digest": "67b450f295" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0141", + "text_digest": "6e36252844", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "When omitted on a well-known type, platforms SHOULD use the default label above.", + "normalized": "when omitted on a well-known type, platforms should use the default label above", + "condition": "When omitted on a well-known type", + "referenced_fields": [], + "compound_parent": null, + "document_order": 466, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1353, + "end_line": 1357, + "section": "Checkout Capability > Entities > Total > Well-Known Types", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "well-known-types" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WELL-KNOWN-TYPES-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 827, + "level": "SHOULD", + "text_digest": "6e36252844" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1353, + "level": "SHOULD", + "text_digest": "6e36252844" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0142", + "text_digest": "df0becb156", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The sign convention for well-known types is schema-enforced: subtractive types (discount, items_discount) MUST have negative amounts", + "normalized": "the sign convention for well-known types is schema-enforced: subtractive types (discount, items_discount) must have negative amounts", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 467, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1353, + "end_line": 1357, + "section": "Checkout Capability > Entities > Total > Well-Known Types", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "well-known-types" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WELL-KNOWN-TYPES-03", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: totals content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 827, + "level": "MUST", + "text_digest": "df0becb156" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1353, + "level": "MUST", + "text_digest": "df0becb156" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0143", + "text_digest": "cf4dce95bc", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "additive types (subtotal, fulfillment, tax, fee) MUST have non-negative amounts.", + "normalized": "additive types (subtotal, fulfillment, tax, fee) must have non-negative amounts", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 467, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1353, + "end_line": 1357, + "section": "Checkout Capability > Entities > Total > Well-Known Types", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "well-known-types" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WELL-KNOWN-TYPES-04", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: totals content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 827, + "level": "MUST", + "text_digest": "cf4dce95bc" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1353, + "level": "MUST", + "text_digest": "cf4dce95bc" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0144", + "text_digest": "26a6f1432c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The `type` field is an open string — businesses MAY use values beyond the well-known set.", + "normalized": "the type field is an open string - businesses may use values beyond the well-known set", + "condition": null, + "referenced_fields": [ + "type" + ], + "compound_parent": null, + "document_order": 468, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1359, + "end_line": 1361, + "section": "Checkout Capability > Entities > Total > Well-Known Types", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "well-known-types" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WELL-KNOWN-TYPES-05", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on totals content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on totals content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 833, + "level": "MAY", + "text_digest": "26a6f1432c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1359, + "level": "MAY", + "text_digest": "26a6f1432c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0145", + "text_digest": "3ff1a76ae8", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Unknown types MUST include `display_text` (schema-enforced) and the sign on the amount is self-describing.", + "normalized": "unknown types must include display_text (schema-enforced) and the sign on the amount is self-describing", + "condition": null, + "referenced_fields": [ + "display_text" + ], + "compound_parent": null, + "document_order": 469, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1359, + "end_line": 1361, + "section": "Checkout Capability > Entities > Total > Well-Known Types", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "well-known-types" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-WELL-KNOWN-TYPES-06", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: totals content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content", + "note": "same rule as REQ-SHOPPING-CHECKOUT-0132" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 833, + "level": "MUST", + "text_digest": "3ff1a76ae8" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1359, + "level": "MUST", + "text_digest": "3ff1a76ae8" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0146", + "text_digest": "2440b50ae1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "All types except `subtotal` and `total` MAY appear multiple times — for example, multi-jurisdiction tax lines or itemized fees.", + "normalized": "all types except subtotal and total may appear multiple times - for example, multi-jurisdiction tax lines or itemized fees", + "condition": null, + "referenced_fields": [ + "subtotal", + "total" + ], + "compound_parent": null, + "document_order": 470, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1365, + "end_line": 1366, + "section": "Checkout Capability > Entities > Total > Repeating Types", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "repeating-types" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REPEATING-TYPES-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on totals content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on totals content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 839, + "level": "MAY", + "text_digest": "2440b50ae1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1365, + "level": "MAY", + "text_digest": "2440b50ae1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0147", + "text_digest": "c933a8a798", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Each top-level entry MAY include a `lines` array.", + "normalized": "each top-level entry may include a lines array", + "condition": null, + "referenced_fields": [ + "lines" + ], + "compound_parent": null, + "document_order": 471, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1370, + "end_line": 1372, + "section": "Checkout Capability > Entities > Total > Sub-Lines (`lines`)", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "sub-lines-lines" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-SUB-LINES-LINES-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on totals content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on totals content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 844, + "level": "MAY", + "text_digest": "c933a8a798" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1370, + "level": "MAY", + "text_digest": "c933a8a798" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0148", + "text_digest": "c49ea1cbba", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**Invariant:** `sum(lines[].amount)` MUST equal the parent entry's `amount`.", + "normalized": "invariant: sum(lines[].amount) must equal the parent entry's amount", + "condition": null, + "referenced_fields": [ + "amount" + ], + "compound_parent": null, + "document_order": 473, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1374, + "end_line": 1374, + "section": "Checkout Capability > Entities > Total > Sub-Lines (`lines`)", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "sub-lines-lines" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-SUB-LINES-LINES-02", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: totals content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 848, + "level": "MUST", + "text_digest": "c49ea1cbba" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1374, + "level": "MUST", + "text_digest": "c49ea1cbba" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0149", + "text_digest": "880a06d004", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The business controls what MUST be rendered (top-level entries) versus what MAY be optionally surfaced (sub-lines).", + "normalized": "the business controls what must be rendered (top-level entries) versus what may be optionally surfaced (sub-lines)", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 474, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1376, + "end_line": 1378, + "section": "Checkout Capability > Entities > Total > Sub-Lines (`lines`)", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "sub-lines-lines" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-SUB-LINES-LINES-03", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "not a rule (reviewed): describes the rendering split; the obligations are the platform rendering rules", + "review": { + "verdict": "not a rule", + "actor": "PLATFORM", + "testable": false, + "reason": "describes the rendering split; the obligations are the platform rendering rules" + }, + "excluded": true, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 850, + "level": "MUST", + "text_digest": "880a06d004" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1376, + "level": "MUST", + "text_digest": "880a06d004" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0150", + "text_digest": "57a1e5693e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms SHOULD render sub-lines when provided.", + "normalized": "platforms should render sub-lines when provided", + "condition": "when provided", + "referenced_fields": [], + "compound_parent": null, + "document_order": 475, + "source": { + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1376, + "end_line": 1378, + "section": "Checkout Capability > Entities > Total > Sub-Lines (`lines`)", + "block_type": "paragraph", + "page": "specification/shopping/checkout/", + "anchor": "sub-lines-lines" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-SUB-LINES-LINES-04", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout.md", + "start_line": 850, + "level": "SHOULD", + "text_digest": "57a1e5693e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/index.md", + "start_line": 1376, + "level": "SHOULD", + "text_digest": "57a1e5693e" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/checkout/mcp.json b/requirements/catalog/shopping/checkout/mcp.json new file mode 100644 index 0000000..309156a --- /dev/null +++ b/requirements/catalog/shopping/checkout/mcp.json @@ -0,0 +1,729 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/checkout/mcp.md", + "summary": { + "total": 12, + "must_count": 5, + "must_not_count": 2, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 3, + "should_not_count": 0, + "may_count": 2, + "by_level": { + "MAY": 2, + "MUST": 5, + "MUST NOT": 2, + "SHOULD": 3 + }, + "by_actor": { + "BUSINESS": 1, + "IMPLEMENTATION": 4, + "PLATFORM": 4, + "UNRESOLVED": 3 + }, + "by_file": { + "docs/specification/shopping/checkout/mcp.md": 12 + }, + "with_condition": 3, + "with_referenced_fields": 4, + "from_compound_split": 0, + "diagnostics": { + "actor_after_keyword_only": 0, + "actor_low_confidence": 2, + "actor_unresolved": 3, + "annotation_as_obligation": 2, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 2, + "empty_after_split": 0, + "multi_obligation_sentences": 0, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CHECKOUT-0229", + "text_digest": "7d9d798bfd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "MCP clients **MUST** include a `meta` object in every request containing protocol metadata:", + "normalized": "mcp clients must include a meta object in every request containing protocol metadata", + "condition": null, + "referenced_fields": [ + "meta" + ], + "compound_parent": null, + "document_order": 3, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 82, + "end_line": 83, + "section": "Checkout Capability - MCP Binding > Protocol Fundamentals > Request Metadata", + "block_type": "paragraph", + "page": "specification/shopping/checkout/mcp/", + "anchor": "request-metadata" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-REQUEST-METADATA-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-01-23", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/checkout-mcp.md", + "start_line": 78, + "level": "MUST", + "text_digest": "7d9d798bfd" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-mcp.md", + "start_line": 81, + "level": "MUST", + "text_digest": "7d9d798bfd" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 82, + "level": "MUST", + "text_digest": "7d9d798bfd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0230", + "text_digest": "160daf898a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **MAY** include additional metadata fields.", + "normalized": "platforms may include additional metadata fields", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 6, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 106, + "end_line": 110, + "section": "Checkout Capability - MCP Binding > Protocol Fundamentals > Request Metadata", + "block_type": "paragraph", + "page": "specification/shopping/checkout/mcp/", + "anchor": "request-metadata" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-REQUEST-METADATA-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-01-23", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/checkout-mcp.md", + "start_line": 101, + "level": "MAY", + "text_digest": "160daf898a" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-mcp.md", + "start_line": 104, + "level": "MAY", + "text_digest": "160daf898a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 106, + "level": "MAY", + "text_digest": "160daf898a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0231", + "text_digest": "bd19e02460", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "The `checkout` object in the request payload **MUST NOT** contain an `id` field.", + "normalized": "the checkout object in the request payload must not contain an id field", + "condition": null, + "referenced_fields": [ + "checkout", + "id" + ], + "compound_parent": "MCP tools separate resource identification from payload data:", + "document_order": 10, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 120, + "end_line": 123, + "section": "Checkout Capability - MCP Binding > Tools > Identifier Pattern", + "block_type": "list_item", + "page": "specification/shopping/checkout/mcp/", + "anchor": "identifier-pattern" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-IDENTIFIER-PATTERN-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout-mcp.md", + "start_line": 95, + "level": "MUST NOT", + "text_digest": "bd19e02460" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout-mcp.md", + "start_line": 115, + "level": "MUST NOT", + "text_digest": "bd19e02460" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-mcp.md", + "start_line": 118, + "level": "MUST NOT", + "text_digest": "bd19e02460" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 120, + "level": "MUST NOT", + "text_digest": "bd19e02460" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0232", + "text_digest": "b640f75fbf", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST NOT** start a new `update_checkout` operation while the Checkout is `complete_in_progress`.", + "normalized": "the platform must not start a new update_checkout operation while the checkout is complete_in_progress", + "condition": "while the Checkout is `complete_in_progress`", + "referenced_fields": [ + "complete_in_progress", + "update_checkout" + ], + "compound_parent": null, + "document_order": 51, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 392, + "end_line": 396, + "section": "Checkout Capability - MCP Binding > Tools > `update_checkout`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/mcp/", + "anchor": "update_checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-UPDATE-CHECKOUT-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 392, + "level": "MUST NOT", + "text_digest": "b640f75fbf" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0233", + "text_digest": "35bccf4f4a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "If the Business receives a new `update_checkout` request in that state, it **MUST** leave the Checkout unchanged and return the current Checkout with a recoverable error Message.", + "normalized": "if the business receives a new update_checkout request in that state, it must leave the checkout unchanged and return the current checkout with a recoverable error message", + "condition": "If the Business receives a new `update_checkout` request in that state", + "referenced_fields": [ + "update_checkout" + ], + "compound_parent": null, + "document_order": 53, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 392, + "end_line": 396, + "section": "Checkout Capability - MCP Binding > Tools > `update_checkout`", + "block_type": "paragraph", + "page": "specification/shopping/checkout/mcp/", + "anchor": "update_checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-UPDATE-CHECKOUT-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "reviewed: MCP binding; the REST page states the same rule", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "MCP binding; the REST page states the same rule" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 392, + "level": "MUST", + "text_digest": "35bccf4f4a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0234", + "text_digest": "9f730a1543", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **SHOULD** authenticate agents when using MCP transport.", + "normalized": "platforms should authenticate agents when using mcp transport", + "condition": "when using MCP transport", + "referenced_fields": [], + "compound_parent": null, + "document_order": 118, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 740, + "end_line": 742, + "section": "Checkout Capability - MCP Binding > Message Signing", + "block_type": "paragraph", + "page": "specification/shopping/checkout/mcp/", + "anchor": "message-signing" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-MESSAGE-SIGNING-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout-mcp.md", + "start_line": 716, + "level": "SHOULD", + "text_digest": "9f730a1543" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 737, + "level": "SHOULD", + "text_digest": "9f730a1543" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0235", + "text_digest": "833d001a11", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Response signatures are **RECOMMENDED** for:", + "normalized": "response signatures are recommended for", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 142, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 782, + "end_line": 782, + "section": "Checkout Capability - MCP Binding > Message Signing > Response Signing", + "block_type": "paragraph", + "page": "specification/shopping/checkout/mcp/", + "anchor": "response-signing" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-RESPONSE-SIGNING-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout-mcp.md", + "start_line": 758, + "level": "SHOULD", + "text_digest": "833d001a11" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 779, + "level": "SHOULD", + "text_digest": "833d001a11" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0236", + "text_digest": "eb1ea646bd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Response signatures are **OPTIONAL** for:", + "normalized": "response signatures are optional for", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 144, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 786, + "end_line": 786, + "section": "Checkout Capability - MCP Binding > Message Signing > Response Signing", + "block_type": "paragraph", + "page": "specification/shopping/checkout/mcp/", + "anchor": "response-signing" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-RESPONSE-SIGNING-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout-mcp.md", + "start_line": 762, + "level": "MAY", + "text_digest": "eb1ea646bd" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 783, + "level": "MAY", + "text_digest": "eb1ea646bd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0237", + "text_digest": "748fc7ead3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "A conforming MCP transport implementation **MUST**:", + "normalized": "a conforming mcp transport implementation must", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 148, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 807, + "end_line": 807, + "section": "Checkout Capability - MCP Binding > Conformance", + "block_type": "paragraph", + "page": "specification/shopping/checkout/mcp/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-CONFORMANCE-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout-mcp.md", + "start_line": 600, + "level": "MUST", + "text_digest": "748fc7ead3" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout-mcp.md", + "start_line": 601, + "level": "MUST", + "text_digest": "748fc7ead3" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-mcp.md", + "start_line": 783, + "level": "MUST", + "text_digest": "748fc7ead3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 804, + "level": "MUST", + "text_digest": "748fc7ead3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0238", + "text_digest": "89481e6bfe", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "A conforming implementation **SHOULD**:", + "normalized": "a conforming implementation should", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 155, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 817, + "end_line": 817, + "section": "Checkout Capability - MCP Binding > Conformance", + "block_type": "paragraph", + "page": "specification/shopping/checkout/mcp/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-CONFORMANCE-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout-mcp.md", + "start_line": 793, + "level": "SHOULD", + "text_digest": "89481e6bfe" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 814, + "level": "SHOULD", + "text_digest": "89481e6bfe" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0239", + "text_digest": "66b14d426c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.5, + "clause": "Implementers **MUST** apply this transformation:", + "normalized": "implementers must apply this transformation", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 160, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 825, + "end_line": 829, + "section": "Checkout Capability - MCP Binding > Implementation", + "block_type": "paragraph", + "page": "specification/shopping/checkout/mcp/", + "anchor": "implementation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-IMPLEMENTATION-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-01-23", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/checkout-mcp.md", + "start_line": 612, + "level": "MUST", + "text_digest": "66b14d426c" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-mcp.md", + "start_line": 801, + "level": "MUST", + "text_digest": "66b14d426c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 822, + "level": "MUST", + "text_digest": "66b14d426c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0240", + "text_digest": "dc67c9c070", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.5, + "clause": "Implementers **MUST** expose this as an MCP `tools/call` endpoint:", + "normalized": "implementers must expose this as an mcp tools/call endpoint", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 170, + "source": { + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 859, + "end_line": 859, + "section": "Checkout Capability - MCP Binding > Implementation", + "block_type": "paragraph", + "page": "specification/shopping/checkout/mcp/", + "anchor": "implementation" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-MCP-IMPLEMENTATION-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-01-23", + "releases": [ + { + "version": "2026-01-23", + "file": "docs/specification/checkout-mcp.md", + "start_line": 645, + "level": "MUST", + "text_digest": "dc67c9c070" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-mcp.md", + "start_line": 834, + "level": "MUST", + "text_digest": "dc67c9c070" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/mcp.md", + "start_line": 856, + "level": "MUST", + "text_digest": "dc67c9c070" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/checkout/rest.json b/requirements/catalog/shopping/checkout/rest.json new file mode 100644 index 0000000..eeb8b44 --- /dev/null +++ b/requirements/catalog/shopping/checkout/rest.json @@ -0,0 +1,739 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/checkout/rest.md", + "summary": { + "total": 12, + "must_count": 6, + "must_not_count": 1, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 1, + "should_not_count": 0, + "may_count": 4, + "by_level": { + "MAY": 4, + "MUST": 6, + "MUST NOT": 1, + "SHOULD": 1 + }, + "by_actor": { + "BUSINESS": 2, + "PLATFORM": 4, + "UNRESOLVED": 6 + }, + "by_file": { + "docs/specification/shopping/checkout/rest.md": 12 + }, + "with_condition": 5, + "with_referenced_fields": 2, + "from_compound_split": 0, + "diagnostics": { + "actor_after_keyword_only": 0, + "actor_low_confidence": 0, + "actor_unresolved": 6, + "annotation_as_obligation": 2, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 0, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-CHECKOUT-0241", + "text_digest": "017f445b50", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "All request and response bodies **MUST** be valid JSON as specified in [RFC 8259](https://tools.ietf.org/html/rfc8259){ target=\"_blank\" }.", + "normalized": "all request and response bodies must be valid json as specified in rfc 8259", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 9, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 71, + "end_line": 72, + "section": "Checkout Capability - REST Binding > Protocol Fundamentals > Content Types", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "content-types" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-CONTENT-TYPES-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: binds both sides; the response half is visible", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "binds both sides; the response half is visible" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout-rest.md", + "start_line": 36, + "level": "MUST", + "text_digest": "017f445b50" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout-rest.md", + "start_line": 36, + "level": "MUST", + "text_digest": "017f445b50" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-rest.md", + "start_line": 36, + "level": "MUST", + "text_digest": "017f445b50" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 71, + "level": "MUST", + "text_digest": "017f445b50" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0242", + "text_digest": "86f31bc40b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "All REST endpoints **MUST** be served over HTTPS with minimum TLS version 1.3.", + "normalized": "all rest endpoints must be served over https with minimum tls version 1.3", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 10, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 76, + "end_line": 77, + "section": "Checkout Capability - REST Binding > Protocol Fundamentals > Transport Security", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "transport-security" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-TRANSPORT-SECURITY-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: visible: the endpoint's TLS version", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the endpoint's TLS version", + "note": "the local sample server serves plain HTTP, so it fails this" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout-rest.md", + "start_line": 41, + "level": "MUST", + "text_digest": "86f31bc40b" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout-rest.md", + "start_line": 41, + "level": "MUST", + "text_digest": "86f31bc40b" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-rest.md", + "start_line": 41, + "level": "MUST", + "text_digest": "86f31bc40b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 76, + "level": "MUST", + "text_digest": "86f31bc40b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0243", + "text_digest": "4bb048462f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST** send the entire Checkout resource, including any data updates to write-only fields; the supplied resource replaces the existing Checkout session state.", + "normalized": "the platform must send the entire checkout resource, including any data updates to write-only fields; the supplied resource replaces the existing checkout session state", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 35, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 231, + "end_line": 238, + "section": "Checkout Capability - REST Binding > Examples > Update Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "update-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-UPDATE-CHECKOUT-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 231, + "level": "MUST", + "text_digest": "4bb048462f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0244", + "text_digest": "abb33abf65", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST NOT** start a new Update Checkout operation while the Checkout is `complete_in_progress`.", + "normalized": "the platform must not start a new update checkout operation while the checkout is complete_in_progress", + "condition": "while the Checkout is `complete_in_progress`", + "referenced_fields": [ + "complete_in_progress" + ], + "compound_parent": null, + "document_order": 36, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 231, + "end_line": 238, + "section": "Checkout Capability - REST Binding > Examples > Update Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "update-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-UPDATE-CHECKOUT-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 231, + "level": "MUST NOT", + "text_digest": "abb33abf65" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0245", + "text_digest": "171c8ac33e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "If the Business receives a new Update Checkout request in that state, it **MUST** leave the Checkout unchanged and return the current Checkout with a recoverable error Message.", + "normalized": "if the business receives a new update checkout request in that state, it must leave the checkout unchanged and return the current checkout with a recoverable error message", + "condition": "If the Business receives a new Update Checkout request in that state", + "referenced_fields": [], + "compound_parent": null, + "document_order": 38, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 231, + "end_line": 238, + "section": "Checkout Capability - REST Binding > Examples > Update Checkout", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "update-checkout" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-UPDATE-CHECKOUT-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 231, + "level": "MUST", + "text_digest": "171c8ac33e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0246", + "text_digest": "036655993f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Outside `complete_in_progress`, each Update Checkout replaces the entire Checkout session, so the Platform **MUST** include all previously set fields it intends to retain.", + "normalized": "outside complete_in_progress, each update checkout replaces the entire checkout session, so the platform must include all previously set fields it intends to retain", + "condition": null, + "referenced_fields": [ + "complete_in_progress" + ], + "compound_parent": null, + "document_order": 40, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 242, + "end_line": 245, + "section": "Checkout Capability - REST Binding > Examples > Update Checkout > Update Buyer Info", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "update-buyer-info" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-UPDATE-BUYER-INFO-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 242, + "level": "MUST", + "text_digest": "036655993f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0247", + "text_digest": "d1ab83442a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **MAY** choose among authentication mechanisms (API keys, OAuth, mTLS, HTTP Message Signatures).", + "normalized": "platforms may choose among authentication mechanisms (api keys, oauth, mtls, http message signatures)", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 92, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1403, + "end_line": 1406, + "section": "Checkout Capability - REST Binding > Message Signing", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "message-signing" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-MESSAGE-SIGNING-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout-rest.md", + "start_line": 1339, + "level": "MAY", + "text_digest": "d1ab83442a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1412, + "level": "MAY", + "text_digest": "d1ab83442a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0248", + "text_digest": "2b1505e5e0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When HTTP Message Signatures are used, requests **MUST** include valid `Signature-Input` and `Signature` headers (and `Content-Digest` when a body is present) per RFC 9421:", + "normalized": "when http message signatures are used, requests must include valid signature-input and signature headers (and content-digest when a body is present) per rfc 9421", + "condition": "When HTTP Message Signatures are used", + "referenced_fields": [], + "compound_parent": null, + "document_order": 94, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1410, + "end_line": 1412, + "section": "Checkout Capability - REST Binding > Message Signing > Request Signing", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "request-signing" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-REQUEST-SIGNING-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": false, + "testable_reason": "reviewed: about the requests the platform signs", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "about the requests the platform signs" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout-rest.md", + "start_line": 1346, + "level": "MUST", + "text_digest": "2b1505e5e0" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1419, + "level": "MUST", + "text_digest": "2b1505e5e0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0249", + "text_digest": "833d001a11", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Response signatures are **RECOMMENDED** for:", + "normalized": "response signatures are recommended for", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 107, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1442, + "end_line": 1442, + "section": "Checkout Capability - REST Binding > Message Signing > Response Signing", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "response-signing" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-RESPONSE-SIGNING-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: visible: response signature headers", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: response signature headers" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout-rest.md", + "start_line": 1378, + "level": "SHOULD", + "text_digest": "833d001a11" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1451, + "level": "SHOULD", + "text_digest": "833d001a11" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0250", + "text_digest": "eb1ea646bd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Response signatures are **OPTIONAL** for:", + "normalized": "response signatures are optional for", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 109, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1446, + "end_line": 1446, + "section": "Checkout Capability - REST Binding > Message Signing > Response Signing", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "response-signing" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-RESPONSE-SIGNING-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: permission; visible when used", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/checkout-rest.md", + "start_line": 1382, + "level": "MAY", + "text_digest": "eb1ea646bd" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1455, + "level": "MAY", + "text_digest": "eb1ea646bd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0251", + "text_digest": "9655f6d29f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When authentication is required, the REST transport **MAY** use:", + "normalized": "when authentication is required, the rest transport may use", + "condition": "When authentication is required", + "referenced_fields": [], + "compound_parent": null, + "document_order": 114, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1469, + "end_line": 1470, + "section": "Checkout Capability - REST Binding > Security Considerations > Authentication", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "authentication" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-AUTHENTICATION-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": false, + "testable_reason": "reviewed: a menu of allowed authentication methods; nothing a test can fail", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "a menu of allowed authentication methods; nothing a test can fail" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout-rest.md", + "start_line": 1340, + "level": "MAY", + "text_digest": "9655f6d29f" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout-rest.md", + "start_line": 1254, + "level": "MAY", + "text_digest": "9655f6d29f" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-rest.md", + "start_line": 1405, + "level": "MAY", + "text_digest": "9655f6d29f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1478, + "level": "MAY", + "text_digest": "9655f6d29f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0252", + "text_digest": "629a6e09eb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.checkout" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MAY** require authentication for some operations while leaving others open (e.g., public checkout without authentication).", + "normalized": "businesses may require authentication for some operations while leaving others open (e.g., public checkout without authentication)", + "condition": "while leaving others open (e.g., public checkout without authentication)", + "referenced_fields": [], + "compound_parent": null, + "document_order": 126, + "source": { + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1481, + "end_line": 1482, + "section": "Checkout Capability - REST Binding > Security Considerations > Authentication", + "block_type": "paragraph", + "page": "specification/shopping/checkout/rest/", + "anchor": "authentication" + }, + "suite": { + "positional_id": "REQ-CHECKOUT-REST-AUTHENTICATION-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/checkout-rest.md", + "start_line": 1349, + "level": "MAY", + "text_digest": "629a6e09eb" + }, + { + "version": "2026-01-23", + "file": "docs/specification/checkout-rest.md", + "start_line": 1263, + "level": "MAY", + "text_digest": "629a6e09eb" + }, + { + "version": "2026-04-08", + "file": "docs/specification/checkout-rest.md", + "start_line": 1417, + "level": "MAY", + "text_digest": "629a6e09eb" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/checkout/rest.md", + "start_line": 1490, + "level": "MAY", + "text_digest": "629a6e09eb" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/extensions/buyer-consent.json b/requirements/catalog/shopping/extensions/buyer-consent.json new file mode 100644 index 0000000..8191dcf --- /dev/null +++ b/requirements/catalog/shopping/extensions/buyer-consent.json @@ -0,0 +1,938 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/extensions/buyer-consent.md", + "summary": { + "total": 17, + "must_count": 7, + "must_not_count": 5, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 2, + "should_not_count": 0, + "may_count": 3, + "by_level": { + "MAY": 3, + "MUST": 7, + "MUST NOT": 5, + "SHOULD": 2 + }, + "by_actor": { + "BUSINESS": 4, + "BUYER": 2, + "PLATFORM": 11 + }, + "by_file": { + "docs/specification/shopping/extensions/buyer-consent.md": 17 + }, + "with_condition": 4, + "with_referenced_fields": 10, + "from_compound_split": 2, + "diagnostics": { + "actor_after_keyword_only": 0, + "actor_low_confidence": 2, + "actor_unresolved": 0, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 1, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0001", + "text_digest": "e83d2886ae", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms MAY submit captured consent on `complete_checkout` alongside payment.", + "normalized": "platforms may submit captured consent on complete_checkout alongside payment", + "condition": null, + "referenced_fields": [ + "complete_checkout" + ], + "compound_parent": null, + "document_order": 22, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 90, + "end_line": 93, + "section": "Buyer Consent Extension > Schema Composition", + "block_type": "paragraph", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "schema-composition" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-SCHEMA-COMPOSITION-01", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 90, + "level": "MAY", + "text_digest": "e83d2886ae" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0002", + "text_digest": "c9f256df93", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "On `create_cart`, `update_cart`, `create_checkout`, and `update_checkout`, businesses SHOULD surface missing dependencies as `warning` messages so the platform can collect the data on a subsequent operation.", + "normalized": "on create_cart, update_cart, create_checkout, and update_checkout, businesses should surface missing dependencies as warning messages so the platform can collect the data on a subsequent operation", + "condition": null, + "referenced_fields": [ + "create_cart", + "create_checkout", + "update_cart", + "update_checkout", + "warning" + ], + "compound_parent": null, + "document_order": 77, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 336, + "end_line": 339, + "section": "Buyer Consent Extension > Data dependencies", + "block_type": "paragraph", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "data-dependencies" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-DATA-DEPENDENCIES-01", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: warning messages in responses", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "warning messages in responses" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 336, + "level": "SHOULD", + "text_digest": "c9f256df93" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0003", + "text_digest": "847433efb5", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST NOT", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "On `complete_checkout`, businesses MUST NOT transition the checkout to `completed` while a confirmed consent decision has unmet data dependencies.", + "normalized": "on complete_checkout, businesses must not transition the checkout to completed while a confirmed consent decision has unmet data dependencies", + "condition": "while a confirmed consent decision has unmet data dependencies", + "referenced_fields": [ + "complete_checkout", + "completed" + ], + "compound_parent": null, + "document_order": 79, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 354, + "end_line": 357, + "section": "Buyer Consent Extension > Data dependencies", + "block_type": "paragraph", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "data-dependencies" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-DATA-DEPENDENCIES-02", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: completion is refused", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: completion is refused" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 354, + "level": "MUST NOT", + "text_digest": "847433efb5" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0004", + "text_digest": "ad6ce21b41", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST", + "target_actor": "BUYER", + "actor_confidence": 0.5, + "clause": "Missing dependencies MUST be surfaced via the standard [Error Handling](../checkout/index.md#error-handling) flow.", + "normalized": "missing dependencies must be surfaced via the standard error handling flow", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 80, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 354, + "end_line": 357, + "section": "Buyer Consent Extension > Data dependencies", + "block_type": "paragraph", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "data-dependencies" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-DATA-DEPENDENCIES-03", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: the business surfaces them (the extractor read 'buyer')", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "the business surfaces them (the extractor read 'buyer')" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 354, + "level": "MUST", + "text_digest": "ad6ce21b41" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0005", + "text_digest": "0a45016c80", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "**Use the advertised settings.** Businesses MUST advertise the complete set of consent options they support.", + "normalized": "use the advertised settings. businesses must advertise the complete set of consent options they support", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 81, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 361, + "end_line": 370, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-01", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: completeness against a business's internal consent catalog is not observable over the wire beyond advertising buyer.consent and ignoring unadvertised keys (BUYER-CONSENT-0010)", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "completeness against a business's internal consent catalog is not observable over the wire beyond advertising buyer.consent and ignoring unadvertised keys (BUYER-CONSENT-0010)" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 361, + "level": "MUST", + "text_digest": "0a45016c80" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0006", + "text_digest": "226370a92e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms decide which choices to present to the buyer and when; when presenting a choice, platforms MUST use the advertised `description`, `links`, `granted` value, and purpose/segment grouping.", + "normalized": "platforms decide which choices to present to the buyer and when; when presenting a choice, platforms must use the advertised description, links, granted value, and purpose/segment grouping", + "condition": "when; when presenting a choice", + "referenced_fields": [ + "description", + "granted", + "links" + ], + "compound_parent": null, + "document_order": 82, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 361, + "end_line": 370, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-02", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 361, + "level": "MUST", + "text_digest": "226370a92e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0007", + "text_digest": "13c85fda79", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Identifiers outside the `dev.ucp.consent.*` namespace are opaque handles; platforms MUST NOT infer semantics from such paths alone.", + "normalized": "identifiers outside the dev.ucp.consent.* namespace are opaque handles; platforms must not infer semantics from such paths alone", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 84, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 361, + "end_line": 370, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-03", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 361, + "level": "MUST NOT", + "text_digest": "13c85fda79" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0008", + "text_digest": "0251ef1234", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "When submitting `consent`, platforms MUST include every advertised purpose and segment key, carrying both `granted` and `source` for each.", + "normalized": "when submitting consent, platforms must include every advertised purpose and segment key, carrying both granted and source for each", + "condition": "When submitting `consent`", + "referenced_fields": [ + "consent", + "granted", + "source" + ], + "compound_parent": null, + "document_order": 87, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 372, + "end_line": 377, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-04", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 372, + "level": "MUST", + "text_digest": "0251ef1234" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0009", + "text_digest": "4bdc908f46", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST NOT", + "target_actor": "BUYER", + "actor_confidence": 0.5, + "clause": "Omitting an advertised key within a submitted `consent` map MUST NOT be used to signal any value.", + "normalized": "omitting an advertised key within a submitted consent map must not be used to signal any value", + "condition": null, + "referenced_fields": [ + "consent" + ], + "compound_parent": null, + "document_order": 88, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 372, + "end_line": 377, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-05", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: about the consent map the platform submits (the extractor read 'buyer')", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "about the consent map the platform submits (the extractor read 'buyer')" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 372, + "level": "MUST NOT", + "text_digest": "4bdc908f46" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0010", + "text_digest": "7affd65168", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "**Advertised set is authoritative.** Businesses MUST ignore purposes and segments in a request that were not advertised in a prior response.", + "normalized": "advertised set is authoritative. businesses must ignore purposes and segments in a request that were not advertised in a prior response", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 89, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 379, + "end_line": 382, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-06", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: unadvertised entries are ignored", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: unadvertised entries are ignored" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 379, + "level": "MUST", + "text_digest": "7affd65168" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0011", + "text_digest": "7918cf85e6", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms MUST NOT prompt for or transmit purposes or segments the business did not advertise.", + "normalized": "platforms must not prompt for or transmit purposes or segments the business did not advertise", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 90, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 379, + "end_line": 382, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-07", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 379, + "level": "MUST NOT", + "text_digest": "7918cf85e6" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0012", + "text_digest": "9ea5b9f143", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "**Source attribution requires a buyer-stated preference.** Platforms MUST set `source: \"platform\"` only when the `granted` value reflects the buyer's stated preference.", + "normalized": "source attribution requires a buyer-stated preference. platforms must set source: \"platform\" only when the granted value reflects the buyer's stated preference", + "condition": "when the `granted` value reflects the buyer's stated preference", + "referenced_fields": [ + "granted", + "source" + ], + "compound_parent": null, + "document_order": 92, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 387, + "end_line": 392, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-08", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 387, + "level": "MUST", + "text_digest": "9ea5b9f143" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0013", + "text_digest": "d0e9b52bdd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "For choices to which no buyer preference applies, platforms MUST echo the advertised `source` unchanged.", + "normalized": "for choices to which no buyer preference applies, platforms must echo the advertised source unchanged", + "condition": null, + "referenced_fields": [ + "source" + ], + "compound_parent": null, + "document_order": 93, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 387, + "end_line": 392, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-09", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 387, + "level": "MUST", + "text_digest": "d0e9b52bdd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0014", + "text_digest": "72244fd689", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "**Per-business attribution.** A consent decision captured with a specific business is attributable only to that business; platforms MUST NOT propagate it as the basis for `source: \"platform\"` in a different business's request.", + "normalized": "per-business attribution. a consent decision captured with a specific business is attributable only to that business; platforms must not propagate it as the basis for source: \"platform\" in a different business's request", + "condition": null, + "referenced_fields": [ + "source" + ], + "compound_parent": null, + "document_order": 95, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 394, + "end_line": 399, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-10", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 394, + "level": "MUST NOT", + "text_digest": "72244fd689" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0015", + "text_digest": "6b49f63890", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "**Persistence and reversibility.** Platforms MAY persist a buyer's prior preferences (`source: \"platform\"`) across interactions with the same business", + "normalized": "persistence and reversibility. platforms may persist a buyer's prior preferences (source: \"platform\") across interactions with the same business", + "condition": null, + "referenced_fields": [ + "source" + ], + "compound_parent": null, + "document_order": 97, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 401, + "end_line": 405, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-11", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 401, + "level": "MAY", + "text_digest": "6b49f63890" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0016", + "text_digest": "40c2df7171", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "**Persistence and reversibility.** Platforms MAY suppress re-presentation of unchanged values.", + "normalized": "persistence and reversibility. platforms may suppress re-presentation of unchanged values", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 97, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 401, + "end_line": 405, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-12", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 401, + "level": "MAY", + "text_digest": "40c2df7171" + } + ] + } + }, + { + "id": "REQ-SHOPPING-BUYER-CONSENT-0017", + "text_digest": "047c97c48a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.buyer_consent" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Where preferences are persisted, platforms SHOULD give the buyer the ability to change them.", + "normalized": "where preferences are persisted, platforms should give the buyer the ability to change them", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 98, + "source": { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 401, + "end_line": 405, + "section": "Buyer Consent Extension > Normative requirements", + "block_type": "list_item", + "page": "specification/shopping/extensions/buyer-consent/", + "anchor": "normative-requirements" + }, + "suite": { + "positional_id": "REQ-SHOPPING-BUYER-CONSENT-BUYERCONSENT-NORMATIVE-REQUIREMENTS-13", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "start_line": 401, + "level": "SHOULD", + "text_digest": "047c97c48a" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/extensions/discount.json b/requirements/catalog/shopping/extensions/discount.json new file mode 100644 index 0000000..a734f12 --- /dev/null +++ b/requirements/catalog/shopping/extensions/discount.json @@ -0,0 +1,578 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/extensions/discount.md", + "summary": { + "total": 9, + "must_count": 5, + "must_not_count": 0, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 3, + "should_not_count": 0, + "may_count": 1, + "by_level": { + "MAY": 1, + "MUST": 5, + "SHOULD": 3 + }, + "by_actor": { + "BUSINESS": 4, + "EXTENSION": 2, + "IMPLEMENTATION": 1, + "PLATFORM": 2 + }, + "by_file": { + "docs/specification/shopping/extensions/discount.md": 9 + }, + "with_condition": 3, + "with_referenced_fields": 5, + "from_compound_split": 0, + "diagnostics": { + "actor_after_keyword_only": 0, + "actor_low_confidence": 2, + "actor_unresolved": 0, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 0, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-DISCOUNT-0001", + "text_digest": "75a607ee1b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.discount" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses MAY advertise discount support for cart only, checkout only, or both.", + "normalized": "businesses may advertise discount support for cart only, checkout only, or both", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 11, + "source": { + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 60, + "end_line": 62, + "section": "Discount Extension > Discovery", + "block_type": "paragraph", + "page": "specification/shopping/extensions/discount/", + "anchor": "discovery" + }, + "suite": { + "positional_id": "REQ-SHOPPING-DISCOUNT-DISCOUNT-DISCOVERY-01", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; visible in discovery", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible in discovery" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/discount.md", + "start_line": 59, + "level": "MAY", + "text_digest": "75a607ee1b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 60, + "level": "MAY", + "text_digest": "75a607ee1b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0002", + "text_digest": "15ac700129", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.discount" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms SHOULD check which resources are extended before submitting discount codes.", + "normalized": "platforms should check which resources are extended before submitting discount codes", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 12, + "source": { + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 60, + "end_line": 62, + "section": "Discount Extension > Discovery", + "block_type": "paragraph", + "page": "specification/shopping/extensions/discount/", + "anchor": "discovery" + }, + "suite": { + "positional_id": "REQ-SHOPPING-DISCOUNT-DISCOUNT-DISCOVERY-02", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at the platform", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/discount.md", + "start_line": 59, + "level": "SHOULD", + "text_digest": "15ac700129" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 60, + "level": "SHOULD", + "text_digest": "15ac700129" + } + ] + } + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0003", + "text_digest": "cf1b7d46ea", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.discount" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "**Cart-to-checkout continuity:** When a cart is converted to a checkout via the cart capability's `cart_id` field, businesses MUST carry forward any discount codes that were applied to the cart.", + "normalized": "cart-to-checkout continuity: when a cart is converted to a checkout via the cart capability's cart_id field, businesses must carry forward any discount codes that were applied to the cart", + "condition": "When a cart is converted to a checkout via the cart capability's `cart_id` field", + "referenced_fields": [ + "cart_id" + ], + "compound_parent": null, + "document_order": 52, + "source": { + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 146, + "end_line": 150, + "section": "Discount Extension > Operations", + "block_type": "paragraph", + "page": "specification/shopping/extensions/discount/", + "anchor": "operations" + }, + "suite": { + "positional_id": "REQ-SHOPPING-DISCOUNT-DISCOUNT-OPERATIONS-01", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: codes carried into the checkout", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: codes carried into the checkout" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/discount.md", + "start_line": 143, + "level": "MUST", + "text_digest": "cf1b7d46ea" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 144, + "level": "MUST", + "text_digest": "cf1b7d46ea" + } + ] + } + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0004", + "text_digest": "99931074ea", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.discount" + ], + "level": "SHOULD", + "target_actor": "EXTENSION", + "actor_confidence": 0.5, + "clause": "Codes that are no longer valid at checkout time (e.g., expired, ineligible) SHOULD be communicated via `messages[]` using standard rejection codes.", + "normalized": "codes that are no longer valid at checkout time (e.g., expired, ineligible) should be communicated via messages[] using standard rejection codes", + "condition": null, + "referenced_fields": [ + "messages[]" + ], + "compound_parent": null, + "document_order": 53, + "source": { + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 146, + "end_line": 150, + "section": "Discount Extension > Operations", + "block_type": "paragraph", + "page": "specification/shopping/extensions/discount/", + "anchor": "operations" + }, + "suite": { + "positional_id": "REQ-SHOPPING-DISCOUNT-DISCOUNT-OPERATIONS-02", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: messages in responses", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "messages in responses" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/discount.md", + "start_line": 143, + "level": "SHOULD", + "text_digest": "99931074ea" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 144, + "level": "SHOULD", + "text_digest": "99931074ea" + } + ] + } + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0005", + "text_digest": "05ed0d297c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.discount" + ], + "level": "SHOULD", + "target_actor": "IMPLEMENTATION", + "actor_confidence": 0.9, + "clause": "**Implementation guidance:** Operations that affect order totals, or the user's expectation of the total, **SHOULD** use `type: \"warning\"` to ensure they are surfaced to the user rather than silently handled by platforms.", + "normalized": "implementation guidance: operations that affect order totals, or the user's expectation of the total, should use type: \"warning\" to ensure they are surfaced to the user rather than silently handled by platforms", + "condition": null, + "referenced_fields": [ + "type" + ], + "compound_parent": null, + "document_order": 55, + "source": { + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 169, + "end_line": 173, + "section": "Discount Extension > Rejected Codes", + "block_type": "paragraph", + "page": "specification/shopping/extensions/discount/", + "anchor": "rejected-codes" + }, + "suite": { + "positional_id": "REQ-SHOPPING-DISCOUNT-DISCOUNT-REJECTED-CODES-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: warning type in responses", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "warning type in responses" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/discount.md", + "start_line": 151, + "level": "SHOULD", + "text_digest": "05ed0d297c" + }, + { + "version": "2026-01-23", + "file": "docs/specification/discount.md", + "start_line": 151, + "level": "SHOULD", + "text_digest": "05ed0d297c" + }, + { + "version": "2026-04-08", + "file": "docs/specification/discount.md", + "start_line": 167, + "level": "SHOULD", + "text_digest": "05ed0d297c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 167, + "level": "SHOULD", + "text_digest": "05ed0d297c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0006", + "text_digest": "9e72b57cbb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.discount" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When the discount extension is active, Businesses that choose to accept eligibility claims **MUST** surface their effect on pricing as provisional discounts in the `applied` array.", + "normalized": "when the discount extension is active, businesses that choose to accept eligibility claims must surface their effect on pricing as provisional discounts in the applied array", + "condition": "When the discount extension is active", + "referenced_fields": [ + "applied" + ], + "compound_parent": null, + "document_order": 76, + "source": { + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 198, + "end_line": 203, + "section": "Discount Extension > Eligibility Claims", + "block_type": "paragraph", + "page": "specification/shopping/extensions/discount/", + "anchor": "eligibility-claims" + }, + "suite": { + "positional_id": "REQ-SHOPPING-DISCOUNT-DISCOUNT-ELIGIBILITY-CLAIMS-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/discount.md", + "start_line": 196, + "level": "MUST", + "text_digest": "9e72b57cbb" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 196, + "level": "MUST", + "text_digest": "9e72b57cbb" + } + ] + } + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0007", + "text_digest": "d72ee70a9e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.discount" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **MUST** display provisional discounts to the buyer.", + "normalized": "platforms must display provisional discounts to the buyer", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 77, + "source": { + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 198, + "end_line": 203, + "section": "Discount Extension > Eligibility Claims", + "block_type": "paragraph", + "page": "specification/shopping/extensions/discount/", + "anchor": "eligibility-claims" + }, + "suite": { + "positional_id": "REQ-SHOPPING-DISCOUNT-DISCOUNT-ELIGIBILITY-CLAIMS-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/discount.md", + "start_line": 196, + "level": "MUST", + "text_digest": "d72ee70a9e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 196, + "level": "MUST", + "text_digest": "d72ee70a9e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0008", + "text_digest": "77b348abb6", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.discount" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When a Business recognizes a claim and it affects pricing, it **MUST** surface a corresponding provisional discount in the `discounts.applied` array.", + "normalized": "when a business recognizes a claim and it affects pricing, it must surface a corresponding provisional discount in the discounts.applied array", + "condition": "When a Business recognizes a claim and it affects pricing", + "referenced_fields": [ + "discounts.applied" + ], + "compound_parent": null, + "document_order": 79, + "source": { + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 207, + "end_line": 211, + "section": "Discount Extension > Eligibility Claims > Discount Behavior", + "block_type": "paragraph", + "page": "specification/shopping/extensions/discount/", + "anchor": "discount-behavior" + }, + "suite": { + "positional_id": "REQ-SHOPPING-DISCOUNT-DISCOUNT-DISCOUNT-BEHAVIOR-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/discount.md", + "start_line": 205, + "level": "MUST", + "text_digest": "77b348abb6" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 205, + "level": "MUST", + "text_digest": "77b348abb6" + } + ] + } + }, + { + "id": "REQ-SHOPPING-DISCOUNT-0009", + "text_digest": "b7f23c4704", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.discount" + ], + "level": "MUST", + "target_actor": "EXTENSION", + "actor_confidence": 0.5, + "clause": "At checkout completion, all remaining provisional claims **MUST** be resolved (see [Eligibility Verification at Completion](../checkout/index.md#eligibility-verification-at-completion)).", + "normalized": "at checkout completion, all remaining provisional claims must be resolved (see eligibility verification at completion)", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 97, + "source": { + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 227, + "end_line": 231, + "section": "Discount Extension > Eligibility Claims > Verification at Checkout", + "block_type": "paragraph", + "page": "specification/shopping/extensions/discount/", + "anchor": "verification-at-checkout" + }, + "suite": { + "positional_id": "REQ-SHOPPING-DISCOUNT-DISCOUNT-VERIFICATION-AT-CHECKOUT-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: completion behavior", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "completion behavior", + "note": "restates REQ-SHOPPING-CHECKOUT-0047" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/discount.md", + "start_line": 225, + "level": "MUST", + "text_digest": "b7f23c4704" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/discount.md", + "start_line": 225, + "level": "MUST", + "text_digest": "b7f23c4704" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/extensions/fulfillment.json b/requirements/catalog/shopping/extensions/fulfillment.json new file mode 100644 index 0000000..ea443ca --- /dev/null +++ b/requirements/catalog/shopping/extensions/fulfillment.json @@ -0,0 +1,3035 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/extensions/fulfillment.md", + "summary": { + "total": 55, + "must_count": 16, + "must_not_count": 4, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 15, + "should_not_count": 2, + "may_count": 18, + "by_level": { + "MAY": 18, + "MUST": 16, + "MUST NOT": 4, + "SHOULD": 15, + "SHOULD NOT": 2 + }, + "by_actor": { + "BUSINESS": 33, + "EXTENSION": 9, + "PLATFORM": 13 + }, + "by_file": { + "docs/specification/shopping/extensions/fulfillment.md": 55 + }, + "with_condition": 12, + "with_referenced_fields": 32, + "from_compound_split": 15, + "diagnostics": { + "actor_after_keyword_only": 0, + "actor_low_confidence": 19, + "actor_unresolved": 0, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 1, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 7, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-FULFILLMENT-0001", + "text_digest": "cdbd5fec10", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When Catalog `filters.fulfills_to` is present, a Business **MUST** resolve the fulfillment destination and method `availability` from it rather than from `context`.", + "normalized": "when catalog filters.fulfills_to is present, a business must resolve the fulfillment destination and method availability from it rather than from context", + "condition": "When Catalog `filters.fulfills_to` is present", + "referenced_fields": [ + "availability", + "context", + "filters.fulfills_to" + ], + "compound_parent": "Precedence is scoped to what each field governs:", + "document_order": 39, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 80, + "end_line": 82, + "section": "Fulfillment Extension > Location Context", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "location-context" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-LOCATION-CONTEXT-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 80, + "level": "MUST", + "text_digest": "cdbd5fec10" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0002", + "text_digest": "fe8277d08b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Once a Platform sets `selected_destination_id` on a Checkout method, a Business **MUST** use the referenced destination rather than `context.location` for that method's fulfillment scope.", + "normalized": "once a platform sets selected_destination_id on a checkout method, a business must use the referenced destination rather than context.location for that method's fulfillment scope", + "condition": null, + "referenced_fields": [ + "context.location", + "selected_destination_id" + ], + "compound_parent": "Precedence is scoped to what each field governs:", + "document_order": 41, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 83, + "end_line": 86, + "section": "Fulfillment Extension > Location Context", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "location-context" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-LOCATION-CONTEXT-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 83, + "level": "MUST", + "text_digest": "fe8277d08b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0003", + "text_digest": "40ffef1f4a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "[Cart-to-Checkout conversion](../cart/index.md#cart-to-checkout-conversion) initializes the Checkout from the Cart's `context`, so the Business **MAY** use `loc_123` to generate an initial Checkout fulfillment destination.", + "normalized": "cart-to-checkout conversion initializes the checkout from the cart's context, so the business may use loc_123 to generate an initial checkout fulfillment destination", + "condition": null, + "referenced_fields": [ + "context", + "loc_123" + ], + "compound_parent": null, + "document_order": 46, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 88, + "end_line": 95, + "section": "Fulfillment Extension > Location Context", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "location-context" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-LOCATION-CONTEXT-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 88, + "level": "MAY", + "text_digest": "40ffef1f4a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0004", + "text_digest": "eb39670f05", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The two discriminators play different roles by direction: in Business responses, every destination carries a required `type`, so responses are self-describing; in Platform requests, the method's contract determines who authors `destinations[]` and MAY define a default destination shape when `type` is omitted.", + "normalized": "the two discriminators play different roles by direction: in business responses, every destination carries a required type, so responses are self-describing; in platform requests, the method's contract determines who authors destinations[] and may define a default destination shape when type is omitted", + "condition": "when `type` is omitted", + "referenced_fields": [ + "destinations[]", + "type" + ], + "compound_parent": null, + "document_order": 64, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 222, + "end_line": 229, + "section": "Fulfillment Extension > Destinations", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "destinations" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-DESTINATIONS-01", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: the MAY is for the method's defining contract", + "review": { + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "the MAY is for the method's defining contract" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 222, + "level": "MAY", + "text_digest": "eb39670f05" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0005", + "text_digest": "2526f4c07e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "By default, the Platform does not write a method's `destinations[]`; a contract keyed on the method's `type` **MAY** opt into a Platform-writable request shape:", + "normalized": "by default, the platform does not write a method's destinations[]; a contract keyed on the method's type may opt into a platform-writable request shape", + "condition": null, + "referenced_fields": [ + "destinations[]", + "type" + ], + "compound_parent": null, + "document_order": 65, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 231, + "end_line": 233, + "section": "Fulfillment Extension > Destinations", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "destinations" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-DESTINATIONS-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 231, + "level": "MAY", + "text_digest": "2526f4c07e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0006", + "text_digest": "3049f1a8c3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "EXTENSION", + "actor_confidence": 0.9, + "clause": "That method's defining contract — a future revision of this specification or a negotiated extension — **MAY** narrow the response destination shape or opt into a Platform-writable request shape.", + "normalized": "that method's defining contract - a future revision of this specification or a negotiated extension - may narrow the response destination shape or opt into a platform-writable request shape", + "condition": null, + "referenced_fields": [], + "compound_parent": "Destination `type` is **required in responses and optional in requests**. In responses, every destination carries `type`, so destinations remain self-describing wherever they appear. In requests, `destinations[]` is omitted unless a method-specific contract opts into a Platform-writable shape:", + "document_order": 82, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 252, + "end_line": 258, + "section": "Fulfillment Extension > Destinations", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "destinations" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-DESTINATIONS-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: aimed at future spec revisions and extensions", + "review": { + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "aimed at future spec revisions and extensions" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 252, + "level": "MAY", + "text_digest": "3049f1a8c3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0007", + "text_digest": "09193f5629", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "EXTENSION", + "actor_confidence": 0.5, + "clause": "A request that includes `destinations[]` MUST also include the method's `type`.", + "normalized": "a request that includes destinations[] must also include the method's type", + "condition": null, + "referenced_fields": [ + "destinations[]", + "type" + ], + "compound_parent": null, + "document_order": 83, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 260, + "end_line": 261, + "section": "Fulfillment Extension > Destinations", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "destinations" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-DESTINATIONS-04", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: constrains the request", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "constrains the request" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 260, + "level": "MUST", + "text_digest": "09193f5629" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0008", + "text_digest": "b44067a978", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "The Platform **MUST NOT** write Business Location Destinations into `destinations[]`; it selects a location by submitting its stable, opaque, Business-scoped ID as `selected_destination_id`.", + "normalized": "the platform must not write business location destinations into destinations[]; it selects a location by submitting its stable, opaque, business-scoped id as selected_destination_id", + "condition": null, + "referenced_fields": [ + "destinations[]", + "selected_destination_id" + ], + "compound_parent": null, + "document_order": 95, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 308, + "end_line": 314, + "section": "Fulfillment Extension > Destinations > Business Location Destination", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-location-destination" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-LOCATION-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 308, + "level": "MUST NOT", + "text_digest": "b44067a978" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0009", + "text_digest": "ebf819f726", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MUST** return `type: \"business_location\"`, `id`, and its Buyer-facing `name`", + "normalized": "the business must return type: \"business_location\", id, and its buyer-facing name", + "condition": null, + "referenced_fields": [ + "id", + "name", + "type" + ], + "compound_parent": null, + "document_order": 96, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 308, + "end_line": 314, + "section": "Fulfillment Extension > Destinations > Business Location Destination", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-location-destination" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-LOCATION-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 308, + "level": "MUST", + "text_digest": "ebf819f726" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0010", + "text_digest": "0656640d46", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MAY** return its Postal Address in `address`.", + "normalized": "the business may return its postal address in address", + "condition": null, + "referenced_fields": [ + "address" + ], + "compound_parent": null, + "document_order": 96, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 308, + "end_line": 314, + "section": "Fulfillment Extension > Destinations > Business Location Destination", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-location-destination" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-LOCATION-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 308, + "level": "MAY", + "text_digest": "0656640d46" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0011", + "text_digest": "62c051ee37", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "EXTENSION", + "actor_confidence": 0.5, + "clause": "A non-null `selected_destination_id` **MAY** carry an ID the Platform obtained from a Catalog response, a Location search or lookup, an earlier Checkout, or any other source the Business recognizes for that method.", + "normalized": "a non-null selected_destination_id may carry an id the platform obtained from a catalog response, a location search or lookup, an earlier checkout, or any other source the business recognizes for that method", + "condition": null, + "referenced_fields": [ + "selected_destination_id" + ], + "compound_parent": null, + "document_order": 100, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 353, + "end_line": 356, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "selection-and-location-identity" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-SELECTION-AND-LOCATION-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: about which IDs the platform may send", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "about which IDs the platform may send" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 353, + "level": "MAY", + "text_digest": "62c051ee37" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0012", + "text_digest": "bdf46e29a3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "EXTENSION", + "actor_confidence": 0.5, + "clause": "**MUST** carry that same `selected_destination_id` value on the method; and", + "normalized": "must carry that same selected_destination_id value on the method; and", + "condition": null, + "referenced_fields": [ + "selected_destination_id" + ], + "compound_parent": "When the Business accepts a non-null `selected_destination_id`, its response:", + "document_order": 103, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 360, + "end_line": 360, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "selection-and-location-identity" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-SELECTION-AND-LOCATION-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 360, + "level": "MUST", + "text_digest": "bdf46e29a3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0013", + "text_digest": "ac1221953c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "EXTENSION", + "actor_confidence": 0.5, + "clause": "**MUST** include exactly one destination in that same method's `destinations[]` whose `id` equals it, typed as specified in [Destinations](#destinations) — so the response is self-describing whatever the ID's source.", + "normalized": "must include exactly one destination in that same method's destinations[] whose id equals it, typed as specified in destinations - so the response is self-describing whatever the id's source", + "condition": null, + "referenced_fields": [ + "destinations[]", + "id" + ], + "compound_parent": "When the Business accepts a non-null `selected_destination_id`, its response:", + "document_order": 104, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 361, + "end_line": 364, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "selection-and-location-identity" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-SELECTION-AND-LOCATION-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 361, + "level": "MUST", + "text_digest": "ac1221953c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0014", + "text_digest": "cb549868ae", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MUST** revalidate the selected destination's current availability and terms; recognizing an ID neither reserves inventory nor guarantees eligibility.", + "normalized": "the business must revalidate the selected destination's current availability and terms; recognizing an id neither reserves inventory nor guarantees eligibility", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 105, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 366, + "end_line": 372, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "selection-and-location-identity" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-SELECTION-AND-LOCATION-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 366, + "level": "MUST", + "text_digest": "cb549868ae" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0015", + "text_digest": "3405a629ce", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST NOT", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The Business **MUST NOT** silently substitute another destination: it **MUST NOT** return a different `selected_destination_id`, and **MUST NOT** keep the submitted ID while returning a destination that describes another location.", + "normalized": "the business must not silently substitute another destination: it must not return a different selected_destination_id, and must not keep the submitted id while returning a destination that describes another location", + "condition": "while returning a destination that describes another location", + "referenced_fields": [ + "selected_destination_id" + ], + "compound_parent": null, + "document_order": 106, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 366, + "end_line": 372, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "selection-and-location-identity" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-SELECTION-AND-LOCATION-05", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 366, + "level": "MUST NOT", + "text_digest": "3405a629ce" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0016", + "text_digest": "de41b39472", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When the Business cannot accept a `selected_destination_id` submitted on [Update Checkout](../checkout/index.md#update-checkout) — the ID is not recognized for that method, or revalidation fails — it follows the general behavior for a rejected Update: it **MUST** leave the current Checkout unchanged", + "normalized": "when the business cannot accept a selected_destination_id submitted on update checkout - the id is not recognized for that method, or revalidation fails - it follows the general behavior for a rejected update: it must leave the current checkout unchanged", + "condition": "When the Business cannot accept a `selected_destination_id` submitted on Update Checkout — the ID is not recognized for that method", + "referenced_fields": [ + "selected_destination_id" + ], + "compound_parent": null, + "document_order": 108, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 374, + "end_line": 383, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "selection-and-location-identity" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-SELECTION-AND-LOCATION-06", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 374, + "level": "MUST", + "text_digest": "de41b39472" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0017", + "text_digest": "4b4188b3b6", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "When the Business cannot accept a `selected_destination_id` submitted on [Update Checkout](../checkout/index.md#update-checkout) — the ID is not recognized for that method, or revalidation fails — it follows the general behavior for a rejected Update: it **MUST** return that Checkout with an error Message with `severity: \"recoverable\"` whose `path` selects the attempted method's `selected_destination_id` (for example `$.fulfillment.methods[0].selected_destination_id`).", + "normalized": "when the business cannot accept a selected_destination_id submitted on update checkout - the id is not recognized for that method, or revalidation fails - it follows the general behavior for a rejected update: it must return that checkout with an error message with severity: \"recoverable\" whose path selects the attempted method's selected_destination_id (for example $.fulfillment.methods[0].selected_destination_id)", + "condition": "When the Business cannot accept a `selected_destination_id` submitted on Update Checkout — the ID is not recognized for that method", + "referenced_fields": [ + "path", + "selected_destination_id", + "severity" + ], + "compound_parent": null, + "document_order": 108, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 374, + "end_line": 383, + "section": "Fulfillment Extension > Destinations > Selection and Location Identity", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "selection-and-location-identity" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-SELECTION-AND-LOCATION-07", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 374, + "level": "MUST", + "text_digest": "4b4188b3b6" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0018", + "text_digest": "c7748bb9e7", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**MUST** distinguish this option from its siblings", + "normalized": "must distinguish this option from its siblings", + "condition": null, + "referenced_fields": [], + "compound_parent": "**For `options[].title`:**", + "document_order": 130, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 405, + "end_line": 405, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 178, + "level": "MUST", + "text_digest": "69636c2e67", + "clause": "**MUST** distinguish this option from its siblings" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 177, + "level": "MUST", + "text_digest": "c7748bb9e7" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 177, + "level": "MUST", + "text_digest": "c7748bb9e7" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 405, + "level": "MUST", + "text_digest": "c7748bb9e7" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0019", + "text_digest": "7dcad6bd86", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**SHOULD** include method and speed (e.g., \"Express Shipping\", \"Curbside Pickup\")", + "normalized": "should include method and speed (e.g., \"express shipping\", \"curbside pickup\")", + "condition": null, + "referenced_fields": [], + "compound_parent": "**For `options[].title`:**", + "document_order": 131, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 406, + "end_line": 406, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 179, + "level": "SHOULD", + "text_digest": "7a4c2d337c", + "clause": "**SHOULD** include method and speed (e.g., \"Express Shipping\", \"Curbside Pickup\")" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 178, + "level": "SHOULD", + "text_digest": "7dcad6bd86" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 178, + "level": "SHOULD", + "text_digest": "7dcad6bd86" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 406, + "level": "SHOULD", + "text_digest": "7dcad6bd86" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0020", + "text_digest": "3c15b23155", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**MUST** be sufficient for buyer decision if `description` is absent", + "normalized": "must be sufficient for buyer decision if description is absent", + "condition": "if `description` is absent", + "referenced_fields": [ + "description" + ], + "compound_parent": "**For `options[].title`:**", + "document_order": 132, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 407, + "end_line": 407, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: subjective copywriting quality ('sufficient for buyer decision'); non-empty distinct titles are checked by FULFILLMENT-0018", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "subjective copywriting quality ('sufficient for buyer decision'); non-empty distinct titles are checked by FULFILLMENT-0018" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 181, + "level": "MUST", + "text_digest": "9aa994e2ba", + "clause": "**MUST** be sufficient for buyer decision if `description` is absent" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 179, + "level": "MUST", + "text_digest": "3c15b23155" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 179, + "level": "MUST", + "text_digest": "3c15b23155" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 407, + "level": "MUST", + "text_digest": "3c15b23155" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0021", + "text_digest": "57af5875a4", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST NOT", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**MUST NOT** repeat `title` or `total`—provides supplementary context only", + "normalized": "must not repeat title or total-provides supplementary context only", + "condition": null, + "referenced_fields": [ + "title", + "total" + ], + "compound_parent": "**For `options[].description`:**", + "document_order": 134, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 411, + "end_line": 411, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 185, + "level": "MUST NOT", + "text_digest": "a73cf69190", + "clause": "**MUST NOT** repeat `title` or `total`—provides supplementary context only" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 183, + "level": "MUST NOT", + "text_digest": "57af5875a4" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 183, + "level": "MUST NOT", + "text_digest": "57af5875a4" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 411, + "level": "MUST NOT", + "text_digest": "57af5875a4" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0022", + "text_digest": "7e4d50e16f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**SHOULD** include timing, carrier, or other decision-relevant details", + "normalized": "should include timing, carrier, or other decision-relevant details", + "condition": null, + "referenced_fields": [], + "compound_parent": "**For `options[].description`:**", + "document_order": 135, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 412, + "end_line": 412, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-05", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 186, + "level": "SHOULD", + "text_digest": "acc11310b9", + "clause": "**SHOULD** include timing, carrier, or other decision-relevant details" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 184, + "level": "SHOULD", + "text_digest": "7e4d50e16f" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 184, + "level": "SHOULD", + "text_digest": "7e4d50e16f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 412, + "level": "SHOULD", + "text_digest": "7e4d50e16f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0023", + "text_digest": "b82083a42f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**SHOULD** be a complete phrase (e.g., \"Arrives Dec 12-15 via FedEx\")", + "normalized": "should be a complete phrase (e.g., \"arrives dec 12-15 via fedex\")", + "condition": null, + "referenced_fields": [], + "compound_parent": "**For `options[].description`:**", + "document_order": 136, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 413, + "end_line": 413, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-06", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 187, + "level": "SHOULD", + "text_digest": "e31699662f", + "clause": "**SHOULD** be a complete phrase (e.g., \"Arrives Dec 12-15 via FedEx\")" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 185, + "level": "SHOULD", + "text_digest": "b82083a42f" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 185, + "level": "SHOULD", + "text_digest": "b82083a42f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 413, + "level": "SHOULD", + "text_digest": "b82083a42f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0024", + "text_digest": "210c8c5962", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**MAY** be omitted if title is self-explanatory", + "normalized": "may be omitted if title is self-explanatory", + "condition": "if title is self-explanatory", + "referenced_fields": [], + "compound_parent": "**For `options[].description`:**", + "document_order": 137, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 414, + "end_line": 414, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-07", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 188, + "level": "MAY", + "text_digest": "b69042155a", + "clause": "**MAY** be omitted if title is self-explanatory" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 186, + "level": "MAY", + "text_digest": "210c8c5962" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 186, + "level": "MAY", + "text_digest": "210c8c5962" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 414, + "level": "MAY", + "text_digest": "210c8c5962" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0025", + "text_digest": "d8d326773b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**MUST** be a standalone sentence explaining what, when, and where", + "normalized": "must be a standalone sentence explaining what, when, and where", + "condition": "when, and where", + "referenced_fields": [], + "compound_parent": "**For `available_methods[].description`:**", + "document_order": 139, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 418, + "end_line": 418, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-08", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: natural-language prose requirement ('standalone sentence explaining what, when, and where'); not machine-verifiable across locales", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "natural-language prose requirement ('standalone sentence explaining what, when, and where'); not machine-verifiable across locales" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 192, + "level": "MUST", + "text_digest": "98ebc9e32a", + "clause": "**MUST** be a standalone sentence explaining what, when, and where" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 190, + "level": "MUST", + "text_digest": "d8d326773b" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 190, + "level": "MUST", + "text_digest": "d8d326773b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 418, + "level": "MUST", + "text_digest": "d8d326773b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0026", + "text_digest": "b8449b14d9", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "**SHOULD** be usable verbatim in platform dialogue (e.g., \"Pants available for pickup at Downtown Store today at 2pm\")", + "normalized": "should be usable verbatim in platform dialogue (e.g., \"pants available for pickup at downtown store today at 2pm\")", + "condition": null, + "referenced_fields": [], + "compound_parent": "**For `available_methods[].description`:**", + "document_order": 140, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 419, + "end_line": 420, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-09", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 193, + "level": "SHOULD", + "text_digest": "1f6551d13b", + "clause": "**SHOULD** be usable verbatim in platform dialogue (e.g., \"Pants available for pickup at Downtown Store today at 2pm\")" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 191, + "level": "SHOULD", + "text_digest": "b8449b14d9" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 191, + "level": "SHOULD", + "text_digest": "b8449b14d9" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 419, + "level": "SHOULD", + "text_digest": "b8449b14d9" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0027", + "text_digest": "a953e97c48", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **SHOULD** return `options[]` in a meaningful order (e.g., cheapest first, fastest first)", + "normalized": "businesses should return options[] in a meaningful order (e.g., cheapest first, fastest first)", + "condition": null, + "referenced_fields": [ + "options[]" + ], + "compound_parent": "**For ordering:**", + "document_order": 142, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 424, + "end_line": 425, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-10", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 198, + "level": "SHOULD", + "text_digest": "4ffe4368f5", + "clause": "Businesses **SHOULD** return `options[]` in a meaningful order (e.g., cheapest first, fastest first)" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 196, + "level": "SHOULD", + "text_digest": "a953e97c48" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 196, + "level": "SHOULD", + "text_digest": "a953e97c48" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 424, + "level": "SHOULD", + "text_digest": "a953e97c48" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0028", + "text_digest": "765f49eb7f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **SHOULD** preserve that order", + "normalized": "platforms should preserve that order", + "condition": null, + "referenced_fields": [], + "compound_parent": "**For ordering:**", + "document_order": 143, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 426, + "end_line": 428, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-11", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 426, + "level": "SHOULD", + "text_digest": "765f49eb7f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0029", + "text_digest": "b4c3462586", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **MAY** re-order it (e.g. to match known buyer preferences or surface-specific ranking)", + "normalized": "platforms may re-order it (e.g. to match known buyer preferences or surface-specific ranking)", + "condition": null, + "referenced_fields": [], + "compound_parent": "**For ordering:**", + "document_order": 143, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 426, + "end_line": 428, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-12", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 426, + "level": "MAY", + "text_digest": "b4c3462586" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0030", + "text_digest": "676047abce", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.5, + "clause": "they **MUST** preserve the method/option grouping", + "normalized": "they must preserve the method/option grouping", + "condition": null, + "referenced_fields": [], + "compound_parent": "**For ordering:**", + "document_order": 143, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 426, + "end_line": 428, + "section": "Fulfillment Extension > Rendering > Business Responsibilities", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-13", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: 'they' refers to 'Platforms' in the first half of the sentence", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "'they' refers to 'Platforms' in the first half of the sentence" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 426, + "level": "MUST", + "text_digest": "676047abce" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0031", + "text_digest": "0a0dc9bdef", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **SHOULD** treat fulfillment as a generic, renderable structure:", + "normalized": "platforms should treat fulfillment as a generic, renderable structure", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 144, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 432, + "end_line": 432, + "section": "Fulfillment Extension > Rendering > Platform Responsibilities", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "platform-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-PLATFORM-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 204, + "level": "SHOULD", + "text_digest": "0a0dc9bdef" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 202, + "level": "SHOULD", + "text_digest": "0a0dc9bdef" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 202, + "level": "SHOULD", + "text_digest": "0a0dc9bdef" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 432, + "level": "SHOULD", + "text_digest": "0a0dc9bdef" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0032", + "text_digest": "ae5940e52e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **MAY** provide enhanced UX for recognized method types (store selectors for pickup, carrier logos for shipping), but this is optional.", + "normalized": "platforms may provide enhanced ux for recognized method types (store selectors for pickup, carrier logos for shipping), but this is optional", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 149, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 440, + "end_line": 444, + "section": "Fulfillment Extension > Rendering > Platform Responsibilities", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "platform-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-PLATFORM-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 211, + "level": "MAY", + "text_digest": "ae5940e52e" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 209, + "level": "MAY", + "text_digest": "ae5940e52e" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 209, + "level": "MAY", + "text_digest": "ae5940e52e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 440, + "level": "MAY", + "text_digest": "ae5940e52e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0033", + "text_digest": "10dcc01036", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "When a buyer selects an option the platform cannot fully process, the platform **SHOULD** use `continue_url` to hand off to the business's checkout.", + "normalized": "when a buyer selects an option the platform cannot fully process, the platform should use continue_url to hand off to the business's checkout", + "condition": "When a buyer selects an option the platform cannot fully process", + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 152, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 446, + "end_line": 447, + "section": "Fulfillment Extension > Rendering > Platform Responsibilities", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "platform-responsibilities" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-PLATFORM-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 216, + "level": "SHOULD", + "text_digest": "10dcc01036" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 215, + "level": "SHOULD", + "text_digest": "10dcc01036" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 215, + "level": "SHOULD", + "text_digest": "10dcc01036" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 446, + "level": "SHOULD", + "text_digest": "10dcc01036" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0034", + "text_digest": "c3d38466fe", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "If the buyer chooses pickup but the platform doesn't support split fulfillment, the platform **SHOULD** use `continue_url` to hand off to the business's checkout.", + "normalized": "if the buyer chooses pickup but the platform doesn't support split fulfillment, the platform should use continue_url to hand off to the business's checkout", + "condition": "If the buyer chooses pickup but the platform doesn't support split fulfillment", + "referenced_fields": [ + "continue_url" + ], + "compound_parent": null, + "document_order": 161, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 502, + "end_line": 504, + "section": "Fulfillment Extension > Available Methods", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "available-methods" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-AVAILABLE-METHODS-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 266, + "level": "SHOULD", + "text_digest": "c3d38466fe" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 263, + "level": "SHOULD", + "text_digest": "c3d38466fe" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 263, + "level": "SHOULD", + "text_digest": "c3d38466fe" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 502, + "level": "SHOULD", + "text_digest": "c3d38466fe" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0035", + "text_digest": "c663a9746e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "A Business that advertises pickup at a `location` **MUST** accept that same ID as `selected_destination_id` for that method in Checkout.", + "normalized": "a business that advertises pickup at a location must accept that same id as selected_destination_id for that method in checkout", + "condition": null, + "referenced_fields": [ + "location", + "selected_destination_id" + ], + "compound_parent": "`fulfillment.methods[]` lists the methods available for a variant. Each method has:", + "document_order": 170, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 525, + "end_line": 533, + "section": "Fulfillment Extension > Catalog Discovery > Methods", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "methods" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-METHODS-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 525, + "level": "MUST", + "text_digest": "c663a9746e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0036", + "text_digest": "2cf57b7024", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "EXTENSION", + "actor_confidence": 0.5, + "clause": "Where a method states `availability`, consumers MUST use it for that method", + "normalized": "where a method states availability, consumers must use it for that method", + "condition": null, + "referenced_fields": [ + "availability" + ], + "compound_parent": null, + "document_order": 177, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 541, + "end_line": 545, + "section": "Fulfillment Extension > Catalog Discovery > Methods", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "methods" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-METHODS-02", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: 'consumers' are platforms", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "'consumers' are platforms" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 541, + "level": "MUST", + "text_digest": "2cf57b7024" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0037", + "text_digest": "443d2106bc", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST NOT", + "target_actor": "EXTENSION", + "actor_confidence": 0.5, + "clause": "Where a method states `availability`, consumers MUST NOT infer per-method availability from the variant-level value.", + "normalized": "where a method states availability, consumers must not infer per-method availability from the variant-level value", + "condition": null, + "referenced_fields": [ + "availability" + ], + "compound_parent": null, + "document_order": 177, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 541, + "end_line": 545, + "section": "Fulfillment Extension > Catalog Discovery > Methods", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "methods" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-METHODS-03", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: 'consumers' are platforms", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "'consumers' are platforms" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 541, + "level": "MUST NOT", + "text_digest": "443d2106bc" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0038", + "text_digest": "2212f639d3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "EXTENSION", + "actor_confidence": 0.5, + "clause": "A method MAY carry `options[]`, a representative subset of its fulfillment options — not an exhaustive list.", + "normalized": "a method may carry options[], a representative subset of its fulfillment options - not an exhaustive list", + "condition": null, + "referenced_fields": [ + "options[]" + ], + "compound_parent": null, + "document_order": 178, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 549, + "end_line": 553, + "section": "Fulfillment Extension > Catalog Discovery > Options", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "options" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-OPTIONS-01", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on catalog response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on catalog response content" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 549, + "level": "MAY", + "text_digest": "2212f639d3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0039", + "text_digest": "62d55044f9", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Without a destination or full cart, a Business **SHOULD** preview meaningful boundary options for the Buyer (e.g. cheapest, fastest); more specific options are negotiated in Checkout once the line items and destination are known.", + "normalized": "without a destination or full cart, a business should preview meaningful boundary options for the buyer (e.g. cheapest, fastest); more specific options are negotiated in checkout once the line items and destination are known", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 179, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 549, + "end_line": 553, + "section": "Fulfillment Extension > Catalog Discovery > Options", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "options" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-OPTIONS-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 549, + "level": "SHOULD", + "text_digest": "62d55044f9" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0040", + "text_digest": "a1a4de15f2", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The option is open, so a business MAY annotate it with additional fields.", + "normalized": "the option is open, so a business may annotate it with additional fields", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 182, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 555, + "end_line": 562, + "section": "Fulfillment Extension > Catalog Discovery > Options", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "options" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-OPTIONS-03", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; visible when used", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 555, + "level": "MAY", + "text_digest": "a1a4de15f2" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0041", + "text_digest": "185fc4c8c0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "EXTENSION", + "actor_confidence": 0.5, + "clause": "A method MAY also carry none, surfacing only `type`, `description`, and `availability`; options are nested directly under the method, with no group layer (unlike checkout `methods[].groups[].options[]`).", + "normalized": "a method may also carry none, surfacing only type, description, and availability; options are nested directly under the method, with no group layer (unlike checkout methods[].groups[].options[])", + "condition": null, + "referenced_fields": [ + "availability", + "description", + "type" + ], + "compound_parent": null, + "document_order": 183, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 555, + "end_line": 562, + "section": "Fulfillment Extension > Catalog Discovery > Options", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "options" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-OPTIONS-04", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on catalog response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on catalog response content" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 555, + "level": "MAY", + "text_digest": "185fc4c8c0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0042", + "text_digest": "417161b1bb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "A discovered option `id` lets a Buyer's choice carry forward: a Business **SHOULD** accept the same ID as `methods[].groups[].selected_option_id` in Checkout.", + "normalized": "a discovered option id lets a buyer's choice carry forward: a business should accept the same id as methods[].groups[].selected_option_id in checkout", + "condition": null, + "referenced_fields": [ + "id" + ], + "compound_parent": null, + "document_order": 184, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 564, + "end_line": 568, + "section": "Fulfillment Extension > Catalog Discovery > Options", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "options" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-OPTIONS-05", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 564, + "level": "SHOULD", + "text_digest": "417161b1bb" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0043", + "text_digest": "f9ed828394", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "On a market-scoped Catalog a Business **MAY** narrow results with these hints; otherwise they annotate results rather than remove them.", + "normalized": "on a market-scoped catalog a business may narrow results with these hints; otherwise they annotate results rather than remove them", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 192, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 594, + "end_line": 599, + "section": "Fulfillment Extension > Catalog Discovery > Location and method: `context` and `filters`", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "location-and-method-context-and-filters" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-LOCATION-AND-METHOD-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 594, + "level": "MAY", + "text_digest": "f9ed828394" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0044", + "text_digest": "3a8712da69", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **SHOULD** provide one or the other, not both", + "normalized": "platforms should provide one or the other, not both", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 194, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 600, + "end_line": 608, + "section": "Fulfillment Extension > Catalog Discovery > Location and method: `context` and `filters`", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "location-and-method-context-and-filters" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-LOCATION-AND-METHOD-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 600, + "level": "SHOULD", + "text_digest": "3a8712da69" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0045", + "text_digest": "100391f5f5", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "if both are present, a business **SHOULD** use the more specific — typically `location`.", + "normalized": "if both are present, a business should use the more specific - typically location", + "condition": "if both are present", + "referenced_fields": [ + "location" + ], + "compound_parent": null, + "document_order": 194, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 600, + "end_line": 608, + "section": "Fulfillment Extension > Catalog Discovery > Location and method: `context` and `filters`", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "location-and-method-context-and-filters" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-LOCATION-AND-METHOD-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 600, + "level": "SHOULD", + "text_digest": "100391f5f5" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0046", + "text_digest": "ae3b66a72c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.5, + "clause": "A party that does not expose catalog discovery MAY narrow `extends` to `\"dev.ucp.shopping.checkout\"` (string form) or to a single-element array.", + "normalized": "a party that does not expose catalog discovery may narrow extends to \"dev.ucp.shopping.checkout\" (string form) or to a single-element array", + "condition": null, + "referenced_fields": [ + "extends" + ], + "compound_parent": null, + "document_order": 215, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 724, + "end_line": 725, + "section": "Fulfillment Extension > Configuration > Platform Profile", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "platform-profile" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-PLATFORM-PROFILE-01", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: about the platform profile", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "about the platform profile" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 724, + "level": "MAY", + "text_digest": "ae3b66a72c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0047", + "text_digest": "37e1ff580a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Opt-in declaration (business MAY return multiple groups per method):", + "normalized": "opt-in declaration (business may return multiple groups per method)", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 216, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 727, + "end_line": 727, + "section": "Fulfillment Extension > Configuration > Platform Profile", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "platform-profile" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-PLATFORM-PROFILE-02", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; visible when used", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 727, + "level": "MAY", + "text_digest": "37e1ff580a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0048", + "text_digest": "5a0da8cb6d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Business **MUST** consolidate all items into a **single group per method**", + "normalized": "business must consolidate all items into a single group per method", + "condition": null, + "referenced_fields": [], + "compound_parent": "**When `supports_multi_group: false` (default):**", + "document_order": 221, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 786, + "end_line": 786, + "section": "Fulfillment Extension > Configuration > Business Response Behavior", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-response-behavior" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-RESPONSE-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 324, + "level": "MUST", + "text_digest": "d5a3626ecd", + "clause": "Business **MUST** consolidate all items into a **single group per method**" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 323, + "level": "MUST", + "text_digest": "5a0da8cb6d" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 323, + "level": "MUST", + "text_digest": "5a0da8cb6d" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 786, + "level": "MUST", + "text_digest": "5a0da8cb6d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0049", + "text_digest": "f390899b31", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Business **MAY** still return multiple methods (e.g., shipping + pickup) if cart items require it", + "normalized": "business may still return multiple methods (e.g., shipping + pickup) if cart items require it", + "condition": "if cart items require it", + "referenced_fields": [], + "compound_parent": "**When `supports_multi_group: false` (default):**", + "document_order": 224, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 788, + "end_line": 789, + "section": "Fulfillment Extension > Configuration > Business Response Behavior", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-response-behavior" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-RESPONSE-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 327, + "level": "MAY", + "text_digest": "57382e3863", + "clause": "Business **MAY** still return multiple methods (e.g., shipping + pickup) if cart items require it" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 325, + "level": "MAY", + "text_digest": "f390899b31" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 325, + "level": "MAY", + "text_digest": "f390899b31" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 788, + "level": "MAY", + "text_digest": "f390899b31" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0050", + "text_digest": "ea0855e957", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Business **MAY** return multiple groups per method based on inventory, packaging, or warehouse logic", + "normalized": "business may return multiple groups per method based on inventory, packaging, or warehouse logic", + "condition": null, + "referenced_fields": [], + "compound_parent": "**When `supports_multi_group: true`:**", + "document_order": 226, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 793, + "end_line": 794, + "section": "Fulfillment Extension > Configuration > Business Response Behavior", + "block_type": "list_item", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "business-response-behavior" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-BUSINESS-RESPONSE-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/fulfillment.md", + "start_line": 332, + "level": "MAY", + "text_digest": "75e8361a86", + "clause": "Business **MAY** return multiple groups per method based on inventory, packaging, or warehouse logic" + }, + { + "version": "2026-01-23", + "file": "docs/specification/fulfillment.md", + "start_line": 330, + "level": "MAY", + "text_digest": "ea0855e957" + }, + { + "version": "2026-04-08", + "file": "docs/specification/fulfillment.md", + "start_line": 330, + "level": "MAY", + "text_digest": "ea0855e957" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 793, + "level": "MAY", + "text_digest": "ea0855e957" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0051", + "text_digest": "746f0c1c71", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Presentation is method-agnostic: platforms **SHOULD** present every method, rendering `description` and `availability` regardless of its `type` (see [Rendering](#rendering))", + "normalized": "presentation is method-agnostic: platforms should present every method, rendering description and availability regardless of its type (see rendering)", + "condition": null, + "referenced_fields": [ + "availability", + "description", + "type" + ], + "compound_parent": null, + "document_order": 229, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 800, + "end_line": 805, + "section": "Fulfillment Extension > Configuration > Method Types", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "method-types" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-METHOD-TYPES-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 800, + "level": "SHOULD", + "text_digest": "746f0c1c71" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0052", + "text_digest": "f3e16becc1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD NOT", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Presentation is method-agnostic: platforms **SHOULD NOT** omit a method solely because they do not recognize its `type`.", + "normalized": "presentation is method-agnostic: platforms should not omit a method solely because they do not recognize its type", + "condition": null, + "referenced_fields": [ + "type" + ], + "compound_parent": null, + "document_order": 229, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 800, + "end_line": 805, + "section": "Fulfillment Extension > Configuration > Method Types", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "method-types" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-METHOD-TYPES-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 800, + "level": "SHOULD NOT", + "text_digest": "f3e16becc1" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0053", + "text_digest": "79e7a637e6", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "A business **SHOULD** model same-scope variation (e.g. Standard vs Express) as `options`", + "normalized": "a business should model same-scope variation (e.g. standard vs express) as options", + "condition": null, + "referenced_fields": [ + "options" + ], + "compound_parent": null, + "document_order": 232, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 807, + "end_line": 813, + "section": "Fulfillment Extension > Configuration > Method Types", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "method-types" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-METHOD-TYPES-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 807, + "level": "SHOULD", + "text_digest": "79e7a637e6" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0054", + "text_digest": "15788b383d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "SHOULD NOT", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "A business **SHOULD NOT** emit multiple methods that differ only in option-level detail.", + "normalized": "a business should not emit multiple methods that differ only in option-level detail", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 232, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 807, + "end_line": 813, + "section": "Fulfillment Extension > Configuration > Method Types", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "method-types" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-METHOD-TYPES-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 807, + "level": "SHOULD NOT", + "text_digest": "15788b383d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-FULFILLMENT-0055", + "text_digest": "378c4f8068", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.fulfillment" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "**Adding method types.** Because `type` is an open string, a business MAY introduce a new value at any time with no consumer change: it advertises the value (and filters on it via `filters.methods`), and consumers present it like any other method.", + "normalized": "adding method types. because type is an open string, a business may introduce a new value at any time with no consumer change: it advertises the value (and filters on it via filters.methods), and consumers present it like any other method", + "condition": null, + "referenced_fields": [ + "filters.methods", + "type" + ], + "compound_parent": null, + "document_order": 242, + "source": { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 823, + "end_line": 826, + "section": "Fulfillment Extension > Configuration > Method Types", + "block_type": "paragraph", + "page": "specification/shopping/extensions/fulfillment/", + "anchor": "method-types" + }, + "suite": { + "positional_id": "REQ-SHOPPING-FULFILLMENT-FULFILLMENT-METHOD-TYPES-05", + "capability_source": "path", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission; visible when used", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/extensions/fulfillment.md", + "start_line": 823, + "level": "MAY", + "text_digest": "378c4f8068" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/order/index.json b/requirements/catalog/shopping/order/index.json new file mode 100644 index 0000000..3f24368 --- /dev/null +++ b/requirements/catalog/shopping/order/index.json @@ -0,0 +1,1489 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/order/index.md", + "summary": { + "total": 26, + "must_count": 17, + "must_not_count": 0, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 4, + "should_not_count": 0, + "may_count": 5, + "by_level": { + "MAY": 5, + "MUST": 17, + "SHOULD": 4 + }, + "by_actor": { + "BUSINESS": 9, + "PLATFORM": 2, + "UNRESOLVED": 15 + }, + "by_file": { + "docs/specification/shopping/order/index.md": 26 + }, + "with_condition": 2, + "with_referenced_fields": 4, + "from_compound_split": 2, + "diagnostics": { + "actor_after_keyword_only": 3, + "actor_low_confidence": 0, + "actor_unresolved": 15, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 1, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-ORDER-0001", + "text_digest": "db110c82c0", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** include all line items that ever existed on the order regardless of edits or alterations", + "normalized": "must include all line items that ever existed on the order regardless of edits or alterations", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Line Items** — what was purchased at checkout:", + "document_order": 8, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 34, + "end_line": 35, + "section": "Order Capability > Overview > Key Concepts", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "key-concepts" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-KEY-CONCEPTS-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: order response content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "order response content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 34, + "level": "MUST", + "text_digest": "db110c82c0" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 34, + "level": "MUST", + "text_digest": "db110c82c0" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0002", + "text_digest": "cc3d0c0f7a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "SHOULD", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **SHOULD** append new entries rather than mutating existing ones; append-only ledger is preferred.", + "normalized": "businesses should append new entries rather than mutating existing ones; append-only ledger is preferred", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Adjustments** — post-order events independent of fulfillment:", + "document_order": 16, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 47, + "end_line": 50, + "section": "Order Capability > Overview > Key Concepts", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "key-concepts" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-KEY-CONCEPTS-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 47, + "level": "SHOULD", + "text_digest": "cc3d0c0f7a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 47, + "level": "SHOULD", + "text_digest": "cc3d0c0f7a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0003", + "text_digest": "680173e292", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses that do not maintain adjustment history **MAY** perform in-place updates of existing entries (e.g. a single `return` adjustment can transition from `pending` to `completed`)", + "normalized": "businesses that do not maintain adjustment history may perform in-place updates of existing entries (e.g. a single return adjustment can transition from pending to completed)", + "condition": null, + "referenced_fields": [ + "completed", + "pending", + "return" + ], + "compound_parent": "**Adjustments** — post-order events independent of fulfillment:", + "document_order": 17, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 47, + "end_line": 50, + "section": "Order Capability > Overview > Key Concepts", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "key-concepts" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-KEY-CONCEPTS-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 47, + "level": "MAY", + "text_digest": "680173e292" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 47, + "level": "MAY", + "text_digest": "680173e292" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0004", + "text_digest": "5e0b5a836c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses MAY surface a snapshot of the originating checkout's `attribution` on the order.", + "normalized": "businesses may surface a snapshot of the originating checkout's attribution on the order", + "condition": null, + "referenced_fields": [ + "attribution" + ], + "compound_parent": null, + "document_order": 40, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 105, + "end_line": 108, + "section": "Order Capability > Data Model > Attribution", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "attribution" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-ATTRIBUTION-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on order content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on order content" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 92, + "level": "MAY", + "text_digest": "5e0b5a836c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 105, + "level": "MAY", + "text_digest": "5e0b5a836c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0005", + "text_digest": "f650fb481d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses MAY surface a snapshot of the policies that applied at checkout on the order.", + "normalized": "businesses may surface a snapshot of the policies that applied at checkout on the order", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 43, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 112, + "end_line": 113, + "section": "Order Capability > Data Model > Policies", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "policies" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-POLICIES-01", + "capability_source": "bullet", + "keyword_style": "capitals", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: permission on order content", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on order content" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 112, + "level": "MAY", + "text_digest": "f650fb481d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0006", + "text_digest": "b3887dba91", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "When the price settles against an actual measurement, the adjustment **MUST** carry the settled `measure`", + "normalized": "when the price settles against an actual measurement, the adjustment must carry the settled measure", + "condition": "When the price settles against an actual measurement", + "referenced_fields": [ + "measure" + ], + "compound_parent": null, + "document_order": 78, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 374, + "end_line": 384, + "section": "Order Capability > Example: count-sold, measure-priced settlement", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "example-count-sold-measure-priced-settlement" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-EXAMPLE-COUNT-SOLD-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: order adjustment content (measure-priced items only)", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "order adjustment content (measure-priced items only)" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 374, + "level": "MUST", + "text_digest": "b3887dba91" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0007", + "text_digest": "7e7fe0b12a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "its unit identity **MUST** match the pricing basis (no conversion), and a pure price settlement uses `quantity: 0` so the count is untouched. (A settled `measure` is Business-recorded fact", + "normalized": "its unit identity must match the pricing basis (no conversion), and a pure price settlement uses quantity: 0 so the count is untouched. (a settled measure is business-recorded fact", + "condition": null, + "referenced_fields": [ + "measure", + "quantity" + ], + "compound_parent": null, + "document_order": 78, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 374, + "end_line": 384, + "section": "Order Capability > Example: count-sold, measure-priced settlement", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "example-count-sold-measure-priced-settlement" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-EXAMPLE-COUNT-SOLD-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: order adjustment content (measure-priced items only)", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "order adjustment content (measure-priced items only)" + }, + "since": "2026-08-25", + "releases": [ + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 374, + "level": "MUST", + "text_digest": "7e7fe0b12a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0008", + "text_digest": "8259428a26", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MUST** return the full order entity on every response.", + "normalized": "businesses must return the full order entity on every response", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 97, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 554, + "end_line": 558, + "section": "Order Capability > Operations", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "operations" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-OPERATIONS-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 289, + "level": "MUST", + "text_digest": "8259428a26" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 554, + "level": "MUST", + "text_digest": "8259428a26" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0009", + "text_digest": "5f3bf1ba25", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "The business **MUST** authenticate requests to order data before returning a response, using any supported UCP mechanism - API keys, OAuth 2.0, mutual TLS, or HTTP Message Signatures (see [Identity and Authentication](../checkout/rest.md#authentication)).", + "normalized": "the business must authenticate requests to order data before returning a response, using any supported ucp mechanism - api keys, oauth 2.0, mutual tls, or http message signatures (see identity and authentication)", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 107, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 578, + "end_line": 583, + "section": "Order Capability > Operations > Get Order > Authorization", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "authorization" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-AUTHORIZATION-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 313, + "level": "MUST", + "text_digest": "5f3bf1ba25" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 578, + "level": "MUST", + "text_digest": "5f3bf1ba25" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0010", + "text_digest": "68f3d605bf", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "**Platform credentials** (API key, signatures, OAuth client credentials) - businesses **MAY** allow access for orders the platform originated.", + "normalized": "platform credentials (api key, signatures, oauth client credentials) - businesses may allow access for orders the platform originated", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 113, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 590, + "end_line": 594, + "section": "Order Capability > Operations > Get Order > Authorization", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "authorization" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-AUTHORIZATION-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 325, + "level": "MAY", + "text_digest": "68f3d605bf" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 590, + "level": "MAY", + "text_digest": "68f3d605bf" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0011", + "text_digest": "7562bd96a3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MAY", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MAY** define additional access policies (e.g., trusted partner agreements), enforce data availability constraints (e.g., retention windows, regulatory erasure), and omit or redact optional fields from the response based on context, business policy, or other requirements - independently of authorization.", + "normalized": "businesses may define additional access policies (e.g., trusted partner agreements), enforce data availability constraints (e.g., retention windows, regulatory erasure), and omit or redact optional fields from the response based on context, business policy, or other requirements - independently of authorization", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 117, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 601, + "end_line": 605, + "section": "Order Capability > Operations > Get Order > Authorization", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "authorization" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-AUTHORIZATION-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 336, + "level": "MAY", + "text_digest": "7562bd96a3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 601, + "level": "MAY", + "text_digest": "7562bd96a3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0012", + "text_digest": "d79ebec396", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** include `UCP-Agent` header with profile URL on all requests", + "normalized": "must include ucp-agent header with profile url on all requests", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Platform:**", + "document_order": 122, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 662, + "end_line": 662, + "section": "Order Capability > Operations > Guidelines", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "operations-guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-OPERATIONS-GUIDELINES-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: listed under 'Platform:'", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platform:'" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 395, + "level": "MUST", + "text_digest": "d79ebec396" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 662, + "level": "MUST", + "text_digest": "d79ebec396" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0013", + "text_digest": "8fb9d0d3c3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**SHOULD** rely on webhooks (see [Events](#events)) as the primary order update channel and use Get Order for reconciliation or on-demand retrieval", + "normalized": "should rely on webhooks (see events) as the primary order update channel and use get order for reconciliation or on-demand retrieval", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Platform:**", + "document_order": 123, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 663, + "end_line": 664, + "section": "Order Capability > Operations > Guidelines", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "operations-guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-OPERATIONS-GUIDELINES-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: listed under 'Platform:'", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platform:'" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 396, + "level": "SHOULD", + "text_digest": "8fb9d0d3c3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 663, + "level": "SHOULD", + "text_digest": "8fb9d0d3c3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0014", + "text_digest": "e3b0e4d162", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**SHOULD** treat order data as ephemeral and discard it when no longer needed for active commerce flows", + "normalized": "should treat order data as ephemeral and discard it when no longer needed for active commerce flows", + "condition": "when no longer needed for active commerce flows", + "referenced_fields": [], + "compound_parent": "**Platform:**", + "document_order": 124, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 665, + "end_line": 666, + "section": "Order Capability > Operations > Guidelines", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "operations-guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-OPERATIONS-GUIDELINES-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: listed under 'Platform:'", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platform:'" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 398, + "level": "SHOULD", + "text_digest": "e3b0e4d162" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 665, + "level": "SHOULD", + "text_digest": "e3b0e4d162" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0015", + "text_digest": "af7faa7edc", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** authenticate requests to order data before returning a response (see [Authorization](#authorization))", + "normalized": "must authenticate requests to order data before returning a response (see authorization)", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Business:**", + "document_order": 126, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 670, + "end_line": 671, + "section": "Order Capability > Operations > Guidelines", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "operations-guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-OPERATIONS-GUIDELINES-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: unauthenticated requests are refused", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: unauthenticated requests are refused" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 403, + "level": "MUST", + "text_digest": "af7faa7edc" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 670, + "level": "MUST", + "text_digest": "af7faa7edc" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0016", + "text_digest": "6b50b563f9", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "Webhook payloads **MUST** be signed by the business and verified by the platform to ensure authenticity and integrity.", + "normalized": "webhook payloads must be signed by the business and verified by the platform to ensure authenticity and integrity", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 147, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 729, + "end_line": 732, + "section": "Order Capability > Events > Webhook Signature Verification", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "webhook-signature-verification" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-WEBHOOK-SIGNATURE-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: visible: webhook signatures (verifying them is the platform's half)", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: webhook signatures (verifying them is the platform's half)" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/order.md", + "start_line": 303, + "level": "MUST", + "text_digest": "6b50b563f9" + }, + { + "version": "2026-01-23", + "file": "docs/specification/order.md", + "start_line": 295, + "level": "MUST", + "text_digest": "6b50b563f9" + }, + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 459, + "level": "MUST", + "text_digest": "6b50b563f9" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 729, + "level": "MUST", + "text_digest": "6b50b563f9" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0017", + "text_digest": "22a6667ade", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "SHOULD", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **SHOULD** deduplicate on `Webhook-Id`, which short-circuits retries and separates events that share a `Webhook-Timestamp`, whose resolution is one second.", + "normalized": "platforms should deduplicate on webhook-id, which short-circuits retries and separates events that share a webhook-timestamp, whose resolution is one second", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 161, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 751, + "end_line": 756, + "section": "Order Capability > Events > Webhook Signature Verification", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "webhook-signature-verification" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-WEBHOOK-SIGNATURE-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "draft", + "releases": [] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0018", + "text_digest": "2bc16e17be", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": "BUSINESS", + "actor_confidence": 0.9, + "clause": "Businesses **MUST** send retries with the original `Webhook-Id` and `Webhook-Timestamp`: a retry redelivers the same event, and the deduplication and ordering above rely on both values staying constant.", + "normalized": "businesses must send retries with the original webhook-id and webhook-timestamp: a retry redelivers the same event, and the deduplication and ordering above rely on both values staying constant", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 162, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 758, + "end_line": 760, + "section": "Order Capability > Events > Webhook Signature Verification", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "webhook-signature-verification" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-WEBHOOK-SIGNATURE-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "aimed at the business", + "since": "draft", + "releases": [] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0019", + "text_digest": "0392cffe09", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "After verifying the signature, the platform **MUST** confirm the signer is authorized to send events for the referenced order:", + "normalized": "after verifying the signature, the platform must confirm the signer is authorized to send events for the referenced order", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 178, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 808, + "end_line": 809, + "section": "Order Capability > Events > Webhook Signature Verification > Verification (Platform)", + "block_type": "paragraph", + "page": "specification/shopping/order/", + "anchor": "verification-platform" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-VERIFICATION-PLATFORM-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "aimed at the platform", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 512, + "level": "MUST", + "text_digest": "0392cffe09" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 782, + "level": "MUST", + "text_digest": "0392cffe09" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0020", + "text_digest": "f7fb88a8ea", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** respond quickly with a 2xx HTTP status code to acknowledge webhook receipt; process events asynchronously after responding", + "normalized": "must respond quickly with a 2xx http status code to acknowledge webhook receipt; process events asynchronously after responding", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Platform:**", + "document_order": 185, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 827, + "end_line": 828, + "section": "Order Capability > Events > Guidelines", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "events-guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-EVENTS-GUIDELINES-01", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": false, + "testable_reason": "reviewed: listed under 'Platform:'", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platform:'" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 531, + "level": "MUST", + "text_digest": "f7fb88a8ea" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 801, + "level": "MUST", + "text_digest": "f7fb88a8ea" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0021", + "text_digest": "cd10b52eeb", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** include `UCP-Agent` header with profile URL for signer identification", + "normalized": "must include ucp-agent header with profile url for signer identification", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Business:**", + "document_order": 187, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 832, + "end_line": 832, + "section": "Order Capability > Events > Guidelines", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "events-guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-EVENTS-GUIDELINES-02", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: listed under 'Business:'; visible in webhooks", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 536, + "level": "MUST", + "text_digest": "cd10b52eeb" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 806, + "level": "MUST", + "text_digest": "cd10b52eeb" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0022", + "text_digest": "a5e8107f1f", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** sign all webhook payloads per the [Message Signatures](../../signatures.md) specification using RFC 9421 headers (`Signature`, `Signature-Input`, `Content-Digest`)", + "normalized": "must sign all webhook payloads per the message signatures specification using rfc 9421 headers (signature, signature-input, content-digest)", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Business:**", + "document_order": 188, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 833, + "end_line": 835, + "section": "Order Capability > Events > Guidelines", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "events-guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-EVENTS-GUIDELINES-03", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: listed under 'Business:'; visible in webhooks", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 537, + "level": "MUST", + "text_digest": "a5e8107f1f" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 807, + "level": "MUST", + "text_digest": "a5e8107f1f" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0023", + "text_digest": "103d1048ca", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** send \"Order created\" event with fully populated order entity", + "normalized": "must send \"order created\" event with fully populated order entity", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Business:**", + "document_order": 189, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 836, + "end_line": 836, + "section": "Order Capability > Events > Guidelines", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "events-guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-EVENTS-GUIDELINES-04", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: listed under 'Business:'; visible in webhooks", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/order.md", + "start_line": 347, + "level": "MUST", + "text_digest": "6b412de096", + "clause": "**MUST** send \"Order created\" event with fully populated order entity" + }, + { + "version": "2026-01-23", + "file": "docs/specification/order.md", + "start_line": 337, + "level": "MUST", + "text_digest": "103d1048ca" + }, + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 540, + "level": "MUST", + "text_digest": "103d1048ca" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 810, + "level": "MUST", + "text_digest": "103d1048ca" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0024", + "text_digest": "4b626e6827", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** send full order entity on updates (not incremental deltas)", + "normalized": "must send full order entity on updates (not incremental deltas)", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Business:**", + "document_order": 190, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 837, + "end_line": 837, + "section": "Order Capability > Events > Guidelines", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "events-guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-EVENTS-GUIDELINES-05", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: listed under 'Business:'; visible in webhooks", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/order.md", + "start_line": 348, + "level": "MUST", + "text_digest": "195ac0deb4", + "clause": "**MUST** send full order entity on updates (not incremental deltas)" + }, + { + "version": "2026-01-23", + "file": "docs/specification/order.md", + "start_line": 338, + "level": "MUST", + "text_digest": "4b626e6827" + }, + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 541, + "level": "MUST", + "text_digest": "4b626e6827" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 811, + "level": "MUST", + "text_digest": "4b626e6827" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0025", + "text_digest": "1f2d85ce9c", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** retry failed webhook deliveries", + "normalized": "must retry failed webhook deliveries", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Business:**", + "document_order": 191, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 838, + "end_line": 838, + "section": "Order Capability > Events > Guidelines", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "events-guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-EVENTS-GUIDELINES-06", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: listed under 'Business:'; visible in webhooks", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": "docs/specification/order.md", + "start_line": 349, + "level": "MUST", + "text_digest": "d6da9182bb", + "clause": "**MUST** retry failed webhook deliveries" + }, + { + "version": "2026-01-23", + "file": "docs/specification/order.md", + "start_line": 339, + "level": "MUST", + "text_digest": "1f2d85ce9c" + }, + { + "version": "2026-04-08", + "file": "docs/specification/order.md", + "start_line": 542, + "level": "MUST", + "text_digest": "1f2d85ce9c" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/index.md", + "start_line": 812, + "level": "MUST", + "text_digest": "1f2d85ce9c" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0026", + "text_digest": "fbd2ccba30", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** send retries with the original `Webhook-Id` and `Webhook-Timestamp`; a retry redelivers the same event, and platforms deduplicate on `Webhook-Id` and order deliveries by `Webhook-Timestamp`", + "normalized": "must send retries with the original webhook-id and webhook-timestamp; a retry redelivers the same event, and platforms deduplicate on webhook-id and order deliveries by webhook-timestamp", + "condition": null, + "referenced_fields": [], + "compound_parent": "**Business:**", + "document_order": 192, + "source": { + "file": "docs/specification/shopping/order/index.md", + "start_line": 839, + "end_line": 841, + "section": "Order Capability > Events > Guidelines", + "block_type": "list_item", + "page": "specification/shopping/order/", + "anchor": "events-guidelines" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-EVENTS-GUIDELINES-07", + "capability_source": "bullet", + "keyword_style": "bold", + "transport": "core", + "testable": true, + "testable_reason": "reviewed: listed under 'Business:'; visible in webhooks", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + "since": "draft", + "releases": [] + } + } + ] +} diff --git a/requirements/catalog/shopping/order/mcp.json b/requirements/catalog/shopping/order/mcp.json new file mode 100644 index 0000000..334048e --- /dev/null +++ b/requirements/catalog/shopping/order/mcp.json @@ -0,0 +1,423 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/order/mcp.md", + "summary": { + "total": 7, + "must_count": 5, + "must_not_count": 0, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 1, + "should_not_count": 0, + "may_count": 1, + "by_level": { + "MAY": 1, + "MUST": 5, + "SHOULD": 1 + }, + "by_actor": { + "PLATFORM": 3, + "UNRESOLVED": 4 + }, + "by_file": { + "docs/specification/shopping/order/mcp.md": 7 + }, + "with_condition": 0, + "with_referenced_fields": 5, + "from_compound_split": 0, + "diagnostics": { + "actor_after_keyword_only": 1, + "actor_low_confidence": 0, + "actor_unresolved": 4, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 0, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-ORDER-0027", + "text_digest": "7d9d798bfd", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "MCP clients **MUST** include a `meta` object in every request containing protocol metadata:", + "normalized": "mcp clients must include a meta object in every request containing protocol metadata", + "condition": null, + "referenced_fields": [ + "meta" + ], + "compound_parent": null, + "document_order": 3, + "source": { + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 61, + "end_line": 62, + "section": "Order Capability - MCP Binding > Protocol Fundamentals > Request Metadata", + "block_type": "paragraph", + "page": "specification/shopping/order/mcp/", + "anchor": "request-metadata" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-MCP-REQUEST-METADATA-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-mcp.md", + "start_line": 59, + "level": "MUST", + "text_digest": "7d9d798bfd" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 61, + "level": "MUST", + "text_digest": "7d9d798bfd" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0028", + "text_digest": "160daf898a", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MAY", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **MAY** include additional metadata fields.", + "normalized": "platforms may include additional metadata fields", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 5, + "source": { + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 84, + "end_line": 86, + "section": "Order Capability - MCP Binding > Protocol Fundamentals > Request Metadata", + "block_type": "paragraph", + "page": "specification/shopping/order/mcp/", + "anchor": "request-metadata" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-MCP-REQUEST-METADATA-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-mcp.md", + "start_line": 81, + "level": "MAY", + "text_digest": "160daf898a" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 84, + "level": "MAY", + "text_digest": "160daf898a" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0029", + "text_digest": "dfdf1af93d", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": "PLATFORM", + "actor_confidence": 0.9, + "clause": "Platforms **MUST** check `messages` before accessing order fields.", + "normalized": "platforms must check messages before accessing order fields", + "condition": null, + "referenced_fields": [ + "messages" + ], + "compound_parent": null, + "document_order": 22, + "source": { + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 283, + "end_line": 285, + "section": "Order Capability - MCP Binding > Error Handling", + "block_type": "paragraph", + "page": "specification/shopping/order/mcp/", + "anchor": "error-handling" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-MCP-ERROR-HANDLING-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-mcp.md", + "start_line": 276, + "level": "MUST", + "text_digest": "dfdf1af93d" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 283, + "level": "MUST", + "text_digest": "dfdf1af93d" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0030", + "text_digest": "50d0db61d3", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** include `meta.ucp-agent.profile` on all requests", + "normalized": "must include meta.ucp-agent.profile on all requests", + "condition": null, + "referenced_fields": [], + "compound_parent": "Platforms implementing the MCP binding:", + "document_order": 24, + "source": { + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 291, + "end_line": 291, + "section": "Order Capability - MCP Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/order/mcp/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-MCP-CONFORMANCE-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-mcp.md", + "start_line": 284, + "level": "MUST", + "text_digest": "50d0db61d3" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 291, + "level": "MUST", + "text_digest": "50d0db61d3" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0031", + "text_digest": "61b7633392", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** check the `messages` array in responses before accessing order data", + "normalized": "must check the messages array in responses before accessing order data", + "condition": null, + "referenced_fields": [ + "messages" + ], + "compound_parent": "Platforms implementing the MCP binding:", + "document_order": 25, + "source": { + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 292, + "end_line": 292, + "section": "Order Capability - MCP Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/order/mcp/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-MCP-CONFORMANCE-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-mcp.md", + "start_line": 285, + "level": "MUST", + "text_digest": "61b7633392" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 292, + "level": "MUST", + "text_digest": "61b7633392" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0032", + "text_digest": "a8dce026f4", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**SHOULD** delegate to the business via `permalink_url` for the authoritative order experience - the business site is the source of truth for order details and post-purchase operations", + "normalized": "should delegate to the business via permalink_url for the authoritative order experience - the business site is the source of truth for order details and post-purchase operations", + "condition": null, + "referenced_fields": [ + "permalink_url" + ], + "compound_parent": "Platforms implementing the MCP binding:", + "document_order": 26, + "source": { + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 293, + "end_line": 295, + "section": "Order Capability - MCP Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/order/mcp/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-MCP-CONFORMANCE-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-mcp.md", + "start_line": 286, + "level": "SHOULD", + "text_digest": "a8dce026f4" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 293, + "level": "SHOULD", + "text_digest": "a8dce026f4" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0033", + "text_digest": "62046948e1", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** implement the `get_order` tool per the [OpenRPC schema](site:services/shopping/mcp.openrpc.json)", + "normalized": "must implement the get_order tool per the openrpc schema", + "condition": null, + "referenced_fields": [ + "get_order" + ], + "compound_parent": "Businesses implementing the MCP binding:", + "document_order": 28, + "source": { + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 299, + "end_line": 300, + "section": "Order Capability - MCP Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/order/mcp/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-MCP-CONFORMANCE-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "mcp", + "testable": false, + "testable_reason": "MCP binding page", + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-mcp.md", + "start_line": 292, + "level": "MUST", + "text_digest": "62046948e1" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/mcp.md", + "start_line": 299, + "level": "MUST", + "text_digest": "62046948e1" + } + ] + } + } + ] +} diff --git a/requirements/catalog/shopping/order/rest.json b/requirements/catalog/shopping/order/rest.json new file mode 100644 index 0000000..272b2ec --- /dev/null +++ b/requirements/catalog/shopping/order/rest.json @@ -0,0 +1,459 @@ +{ + "$schema": "https://raw.githubusercontent.com/Universal-Commerce-Protocol/.github/main/org-tools/requirements-extractor/schema/requirements-catalog-1.0.0.json", + "schema_version": "1.0.0", + "extractor_version": "0.4.0", + "spec_version": "draft", + "source_file": "docs/specification/shopping/order/rest.md", + "summary": { + "total": 7, + "must_count": 5, + "must_not_count": 0, + "shall_count": 0, + "shall_not_count": 0, + "should_count": 2, + "should_not_count": 0, + "may_count": 0, + "by_level": { + "MUST": 5, + "SHOULD": 2 + }, + "by_actor": { + "UNRESOLVED": 7 + }, + "by_file": { + "docs/specification/shopping/order/rest.md": 7 + }, + "with_condition": 0, + "with_referenced_fields": 2, + "from_compound_split": 0, + "diagnostics": { + "actor_after_keyword_only": 1, + "actor_low_confidence": 0, + "actor_unresolved": 7, + "annotation_as_obligation": 0, + "annotations_excluded": 0, + "candidates_without_emphasis": 0, + "compounds_not_split": 0, + "duplicate_requirements": 0, + "empty_after_split": 0, + "multi_obligation_sentences": 0, + "rfc2119_boilerplate": 0 + } + }, + "suite": { + "spec_commit": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "extractor_commit": "16f3afa45effac5625888afffb2a883e2e4e9b6d", + "options": [ + "capability-from-bullet-or-path", + "count-capitals" + ], + "ids": "stable, from requirements.lock.json" + }, + "requirements": [ + { + "id": "REQ-SHOPPING-ORDER-0034", + "text_digest": "de72b2d0de", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "All response bodies **MUST** be valid JSON as specified in [RFC 8259](https://tools.ietf.org/html/rfc8259){ target=\"_blank\" }.", + "normalized": "all response bodies must be valid json as specified in rfc 8259", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 7, + "source": { + "file": "docs/specification/shopping/order/rest.md", + "start_line": 68, + "end_line": 69, + "section": "Order Capability - REST Binding > Protocol Fundamentals > Content Types", + "block_type": "paragraph", + "page": "specification/shopping/order/rest/", + "anchor": "content-types" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-REST-CONTENT-TYPES-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: response bodies", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response bodies" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-rest.md", + "start_line": 66, + "level": "MUST", + "text_digest": "de72b2d0de" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/rest.md", + "start_line": 68, + "level": "MUST", + "text_digest": "de72b2d0de" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0035", + "text_digest": "86f31bc40b", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "All REST endpoints **MUST** be served over HTTPS with minimum TLS version 1.3.", + "normalized": "all rest endpoints must be served over https with minimum tls version 1.3", + "condition": null, + "referenced_fields": [], + "compound_parent": null, + "document_order": 8, + "source": { + "file": "docs/specification/shopping/order/rest.md", + "start_line": 73, + "end_line": 73, + "section": "Order Capability - REST Binding > Protocol Fundamentals > Transport Security", + "block_type": "paragraph", + "page": "specification/shopping/order/rest/", + "anchor": "transport-security" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-REST-TRANSPORT-SECURITY-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: visible: the endpoint's TLS version", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the endpoint's TLS version", + "note": "the local sample server serves plain HTTP, so it fails this" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-rest.md", + "start_line": 71, + "level": "MUST", + "text_digest": "86f31bc40b" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/rest.md", + "start_line": 73, + "level": "MUST", + "text_digest": "86f31bc40b" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0036", + "text_digest": "15463fa061", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** include `UCP-Agent` header with profile URL on all requests", + "normalized": "must include ucp-agent header with profile url on all requests", + "condition": null, + "referenced_fields": [], + "compound_parent": "Platforms implementing the REST binding:", + "document_order": 27, + "source": { + "file": "docs/specification/shopping/order/rest.md", + "start_line": 249, + "end_line": 249, + "section": "Order Capability - REST Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/order/rest/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-REST-CONFORMANCE-01", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": false, + "testable_reason": "reviewed: listed under 'Platforms implementing the REST binding:'", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platforms implementing the REST binding:'" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-rest.md", + "start_line": 252, + "level": "MUST", + "text_digest": "15463fa061" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/rest.md", + "start_line": 257, + "level": "MUST", + "text_digest": "15463fa061" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0037", + "text_digest": "c299106814", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** check the `messages` array in responses before accessing order data", + "normalized": "must check the messages array in responses before accessing order data", + "condition": null, + "referenced_fields": [ + "messages" + ], + "compound_parent": "Platforms implementing the REST binding:", + "document_order": 28, + "source": { + "file": "docs/specification/shopping/order/rest.md", + "start_line": 250, + "end_line": 250, + "section": "Order Capability - REST Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/order/rest/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-REST-CONFORMANCE-02", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": false, + "testable_reason": "reviewed: listed under 'Platforms implementing the REST binding:'", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platforms implementing the REST binding:'" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-rest.md", + "start_line": 253, + "level": "MUST", + "text_digest": "c299106814" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/rest.md", + "start_line": 258, + "level": "MUST", + "text_digest": "c299106814" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0038", + "text_digest": "a6262d6e2e", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**SHOULD** delegate to the business via `permalink_url` for the authoritative order experience - the business site is the source of truth for order details and post-purchase operations", + "normalized": "should delegate to the business via permalink_url for the authoritative order experience - the business site is the source of truth for order details and post-purchase operations", + "condition": null, + "referenced_fields": [ + "permalink_url" + ], + "compound_parent": "Platforms implementing the REST binding:", + "document_order": 29, + "source": { + "file": "docs/specification/shopping/order/rest.md", + "start_line": 251, + "end_line": 253, + "section": "Order Capability - REST Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/order/rest/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-REST-CONFORMANCE-03", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": false, + "testable_reason": "reviewed: listed under 'Platforms implementing the REST binding:'", + "review": { + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platforms implementing the REST binding:'" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-rest.md", + "start_line": 254, + "level": "SHOULD", + "text_digest": "a6262d6e2e" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/rest.md", + "start_line": 259, + "level": "SHOULD", + "text_digest": "a6262d6e2e" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0039", + "text_digest": "10eaedb9f9", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "MUST", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**MUST** serve all endpoints over HTTPS with TLS 1.3+", + "normalized": "must serve all endpoints over https with tls 1.3+", + "condition": null, + "referenced_fields": [], + "compound_parent": "Businesses implementing the REST binding:", + "document_order": 31, + "source": { + "file": "docs/specification/shopping/order/rest.md", + "start_line": 257, + "end_line": 257, + "section": "Order Capability - REST Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/order/rest/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-REST-CONFORMANCE-04", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: visible: the endpoint's TLS version", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the endpoint's TLS version", + "note": "same rule as REQ-SHOPPING-ORDER-0035" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-rest.md", + "start_line": 260, + "level": "MUST", + "text_digest": "10eaedb9f9" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/rest.md", + "start_line": 265, + "level": "MUST", + "text_digest": "10eaedb9f9" + } + ] + } + }, + { + "id": "REQ-SHOPPING-ORDER-0040", + "text_digest": "f797370582", + "scope": "capability", + "capabilities": [ + "dev.ucp.shopping.order" + ], + "level": "SHOULD", + "target_actor": null, + "actor_confidence": 0.0, + "clause": "**SHOULD** sign responses per the [Message Signatures](../../signatures.md) specification", + "normalized": "should sign responses per the message signatures specification", + "condition": null, + "referenced_fields": [], + "compound_parent": "Businesses implementing the REST binding:", + "document_order": 32, + "source": { + "file": "docs/specification/shopping/order/rest.md", + "start_line": 258, + "end_line": 259, + "section": "Order Capability - REST Binding > Conformance", + "block_type": "list_item", + "page": "specification/shopping/order/rest/", + "anchor": "conformance" + }, + "suite": { + "positional_id": "REQ-SHOPPING-ORDER-REST-CONFORMANCE-05", + "capability_source": "path", + "keyword_style": "bold", + "transport": "rest", + "testable": true, + "testable_reason": "reviewed: visible: response signature headers", + "review": { + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: response signature headers" + }, + "since": "2026-04-08", + "releases": [ + { + "version": "2026-04-08", + "file": "docs/specification/order-rest.md", + "start_line": 261, + "level": "SHOULD", + "text_digest": "f797370582" + }, + { + "version": "2026-08-25", + "file": "docs/specification/shopping/order/rest.md", + "start_line": 266, + "level": "SHOULD", + "text_digest": "f797370582" + } + ] + } + } + ] +} diff --git a/requirements/releases.json b/requirements/releases.json new file mode 100644 index 0000000..ac125da --- /dev/null +++ b/requirements/releases.json @@ -0,0 +1,63 @@ +{ + "about": "The specification releases the catalog's history is read from, oldest first. Each is read at the commit given, the head of its release branch when it was pinned. Releases without a shopping folder keep its pages at the top of docs/specification: flat_pages gives each one's path today, and other_pages lists, as patterns, the pages that aren't shopping pages. Paths are relative to docs/specification.", + "releases": [ + { + "version": "2026-01-11", + "ref": "release/2026-01-11", + "commit": "56bad560fbf7d42cc28a8156152f5da94f2505b9" + }, + { + "version": "2026-01-23", + "ref": "release/2026-01-23", + "commit": "e783ffa2eaeaac9938642a3ddae0f2439b6aa488" + }, + { + "version": "2026-04-08", + "ref": "release/2026-04-08", + "commit": "9c9d6fce39ffa8bf7cb66309c378b79fb75b5382" + }, + { + "version": "2026-08-25", + "ref": "release/2026-08-25", + "commit": "87dd4b1fcff9105d68173120897237fa784c74ef" + } + ], + "flat_pages": { + "buyer-consent.md": "shopping/extensions/buyer-consent.md", + "cart-mcp.md": "shopping/cart/mcp.md", + "cart-rest.md": "shopping/cart/rest.md", + "cart.md": "shopping/cart/index.md", + "catalog/index.md": "shopping/catalog/index.md", + "catalog/lookup.md": "shopping/catalog/lookup.md", + "catalog/mcp.md": "shopping/catalog/mcp.md", + "catalog/rest.md": "shopping/catalog/rest.md", + "catalog/search.md": "shopping/catalog/search.md", + "checkout-a2a.md": "shopping/checkout/a2a.md", + "checkout-mcp.md": "shopping/checkout/mcp.md", + "checkout-rest.md": "shopping/checkout/rest.md", + "checkout.md": "shopping/checkout/index.md", + "discount.md": "shopping/extensions/discount.md", + "embedded-cart.md": "shopping/cart/embedded.md", + "embedded-checkout.md": "shopping/checkout/embedded.md", + "fulfillment.md": "shopping/extensions/fulfillment.md", + "order-mcp.md": "shopping/order/mcp.md", + "order-rest.md": "shopping/order/rest.md", + "order.md": "shopping/order/index.md", + "playground.md": "shopping/playground.md" + }, + "other_pages": [ + "ap2-mandates.md", + "embedded-protocol.md", + "examples/*.md", + "glossary.md", + "identity-linking.md", + "loyalty.md", + "overview.md", + "payment-handler-guide.md", + "payment-handler-template.md", + "permalink.md", + "reference.md", + "signatures.md", + "tokenization-guide.md" + ] +} diff --git a/requirements/review.json b/requirements/review.json new file mode 100644 index 0000000..c316b1d --- /dev/null +++ b/requirements/review.json @@ -0,0 +1,2057 @@ +{ + "about": "Step 9 review of uncertain rules. Keyed by file and text_digest, so decisions survive ID renumbering. Groups: A found only through capitals, B testable with no actor, C business rule on an MCP/A2A/embedded page, E attributed to 'the extension' or 'implementations'.", + "reviewed_against": "f2626c28b8288976eee5bda77f3a9b1ddc0132b1", + "confirmed": "2026-10-20", + "decisions": [ + { + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "6d177cbebb", + "id_at_review": "REQ-SHOPPING-CART-0030", + "groups": "C", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in REST cart responses; applies only to businesses that offer embedded cart" + }, + { + "file": "docs/specification/shopping/cart/embedded.md", + "text_digest": "3bfce93152", + "id_at_review": "REQ-SHOPPING-CART-0031", + "groups": "C", + "verdict": "rule", + "actor": "HOST", + "testable": false, + "reason": "permission for the host, the sentence's subject" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "94c63ccb74", + "id_at_review": "REQ-SHOPPING-CART-0001", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "f2b0ac0e44", + "id_at_review": "REQ-SHOPPING-CART-0002", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform", + "note": "spec typo: cart/index.md repeats 'array (`\"line_items\": []`).' across lines 68-69" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "cbf1d2e8f8", + "id_at_review": "REQ-SHOPPING-CART-0003", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "a checkout created from a cart reflects the cart's contents" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "224effb21d", + "id_at_review": "REQ-SHOPPING-CART-0004", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: conflicting checkout fields are ignored" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "806cb9a689", + "id_at_review": "REQ-SHOPPING-CART-0005", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the same checkout ID comes back" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "7bceaecc6b", + "id_at_review": "REQ-SHOPPING-CART-0006", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "business behavior, but 'linked' is only visible indirectly (through the next rule)" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "c0e93a9c7b", + "id_at_review": "REQ-SHOPPING-CART-0007", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the cart reflects checkout changes" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "eb1bb7f6a1", + "id_at_review": "REQ-SHOPPING-CART-0008", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "1376be1e26", + "id_at_review": "REQ-SHOPPING-CART-0023", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "6e0bf927e2", + "id_at_review": "REQ-SHOPPING-CART-0025", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in the cancel response" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "0fbda2ac13", + "id_at_review": "REQ-SHOPPING-CART-0026", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: later calls return not_found" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "d17ebc6153", + "id_at_review": "REQ-SHOPPING-CART-0027", + "groups": "AB", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "signals are supplied by the platform ('platforms provide signals', checkout page)" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "e0b70c9533", + "id_at_review": "REQ-SHOPPING-CART-0028", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on the totals the business returns" + }, + { + "file": "docs/specification/shopping/cart/index.md", + "text_digest": "c4f79c54ee", + "id_at_review": "REQ-SHOPPING-CART-0029", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/cart/rest.md", + "text_digest": "017f445b50", + "id_at_review": "REQ-SHOPPING-CART-0062", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "binds both sides; the response half is visible" + }, + { + "file": "docs/specification/shopping/cart/rest.md", + "text_digest": "86f31bc40b", + "id_at_review": "REQ-SHOPPING-CART-0063", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the endpoint's TLS version", + "note": "the local sample server serves plain HTTP, so it fails this" + }, + { + "file": "docs/specification/shopping/cart/rest.md", + "text_digest": "9655f6d29f", + "id_at_review": "REQ-SHOPPING-CART-0064", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "a menu of allowed authentication methods; nothing a test can fail" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "40b521f2a3", + "id_at_review": "REQ-SHOPPING-CATALOG-0001", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "about consumers reusing responses" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "96e978ebd7", + "id_at_review": "REQ-SHOPPING-CATALOG-0012", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "35b444ee45", + "id_at_review": "REQ-SHOPPING-CATALOG-0013", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in results when no address is given (weakly)" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "e137bb0b98", + "id_at_review": "REQ-SHOPPING-CATALOG-0014", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "an internal ranking decision; nothing visible to check" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "d647a85835", + "id_at_review": "REQ-SHOPPING-CATALOG-0015", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "about where the business enforces policy; no specific response to check" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "d33d7257de", + "id_at_review": "REQ-SHOPPING-CATALOG-0016", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: price filters in another currency" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "d17ebc6153", + "id_at_review": "REQ-SHOPPING-CATALOG-0019", + "groups": "AB", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "signals are supplied by the platform" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "50fd9f9ad5", + "id_at_review": "REQ-SHOPPING-CATALOG-0025", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "'it' is the platform presenting media" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "972c1b040c", + "id_at_review": "REQ-SHOPPING-CATALOG-0030", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "'it' is the platform embedding a video" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "9525c6155e", + "id_at_review": "REQ-SHOPPING-CATALOG-0032", + "groups": "B", + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "aimed at authors of Action-type contracts" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "1532082837", + "id_at_review": "REQ-SHOPPING-CATALOG-0033", + "groups": "B", + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "aimed at authors of Action-type contracts" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "950a55324b", + "id_at_review": "REQ-SHOPPING-CATALOG-0034", + "groups": "A", + "verdict": "rule", + "actor": "AGENT", + "testable": false, + "reason": "aimed at agents" + }, + { + "file": "docs/specification/shopping/catalog/index.md", + "text_digest": "440c8529d2", + "id_at_review": "REQ-SHOPPING-CATALOG-0035", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on response content", + "note": "the same sentence appears 4 more times on catalog rest.md and mcp.md" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "05e08eb33c", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0001", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; a table-cell restatement of the lookup identifier rules" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "4d7409c0dd", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0002", + "groups": "AE", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "'implementations' are the business's server" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "bb0139a517", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0003", + "groups": "AE", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "fddacf45d0", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0004", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "the server deduplicates; visible in the response" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "1976ef2539", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0005", + "groups": "AE", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "25191003c1", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0006", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in the response" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "67d7d28db3", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0007", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in the response" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "0bedb69a17", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0008", + "groups": "AE", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: send 10 identifiers" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "1531d8ed95", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0009", + "groups": "AE", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible through the error" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "160c793a93", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0010", + "groups": "AE", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: HTTP 400 request_too_large" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "2d2516174f", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0011", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "00e5f417b1", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0012", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "50e0b6763f", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0013", + "groups": "AB", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "constrains the `selected` input the client sends" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "f39f08283c", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0014", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "cc0f65f541", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0015", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on response content" + }, + { + "file": "docs/specification/shopping/catalog/lookup.md", + "text_digest": "515545af2a", + "id_at_review": "REQ-SHOPPING-CATALOG-LOOKUP-0016", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + { + "file": "docs/specification/shopping/catalog/mcp.md", + "text_digest": "440c8529d2", + "id_at_review": "REQ-SHOPPING-CATALOG-0037", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "MCP binding; the REST page states the same rule" + }, + { + "file": "docs/specification/shopping/catalog/mcp.md", + "text_digest": "440c8529d2", + "id_at_review": "REQ-SHOPPING-CATALOG-0038", + "groups": "AC", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "MCP binding; the REST page states the same rule" + }, + { + "file": "docs/specification/shopping/catalog/mcp.md", + "text_digest": "6e5b8536e3", + "id_at_review": "REQ-SHOPPING-CATALOG-0040", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "MCP binding" + }, + { + "file": "docs/specification/shopping/catalog/mcp.md", + "text_digest": "f9a2cc0384", + "id_at_review": "REQ-SHOPPING-CATALOG-0041", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "MCP binding" + }, + { + "file": "docs/specification/shopping/catalog/rest.md", + "text_digest": "440c8529d2", + "id_at_review": "REQ-SHOPPING-CATALOG-0042", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on REST response content" + }, + { + "file": "docs/specification/shopping/catalog/rest.md", + "text_digest": "440c8529d2", + "id_at_review": "REQ-SHOPPING-CATALOG-0043", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on REST response content" + }, + { + "file": "docs/specification/shopping/catalog/rest.md", + "text_digest": "350f72606a", + "id_at_review": "REQ-SHOPPING-CATALOG-0044", + "groups": "E", + "verdict": "not a rule", + "actor": "BUSINESS", + "testable": false, + "reason": "lead-in to a list; the obligations are the list items" + }, + { + "file": "docs/specification/shopping/catalog/rest.md", + "text_digest": "35a3e3f4dd", + "id_at_review": "REQ-SHOPPING-CATALOG-0045", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: both endpoints respond" + }, + { + "file": "docs/specification/shopping/catalog/rest.md", + "text_digest": "f52390f942", + "id_at_review": "REQ-SHOPPING-CATALOG-0046", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: HTTP 200 with fewer products", + "level": "MUST", + "note": "the list's lead-in makes this a MUST; extracted as MAY" + }, + { + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "40c24b8fcb", + "id_at_review": "REQ-SHOPPING-CATALOG-SEARCH-0001", + "groups": "AB", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "constrains the request" + }, + { + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "00372ac58e", + "id_at_review": "REQ-SHOPPING-CATALOG-SEARCH-0002", + "groups": "AE", + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "aimed at extension authors" + }, + { + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "eb6fa97298", + "id_at_review": "REQ-SHOPPING-CATALOG-SEARCH-0003", + "groups": "AE", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: an empty request is rejected" + }, + { + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "b25650806a", + "id_at_review": "REQ-SHOPPING-CATALOG-SEARCH-0004", + "groups": "AE", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: an error for an empty or invalid request" + }, + { + "file": "docs/specification/shopping/catalog/search.md", + "text_digest": "a4f12b4af8", + "id_at_review": "REQ-SHOPPING-CATALOG-SEARCH-0005", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "d3a16bd983", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0152", + "groups": "C", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in REST checkout responses; applies only to businesses that offer embedded checkout" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "81afb6fb27", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0158", + "groups": "C", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "documentation; not visible through the API" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "e5b5268361", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0159", + "groups": "C", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "internal policy in the embedded flow" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "1e3b81573d", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0163", + "groups": "C", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "embedded checkout UI behavior" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "2c534b146e", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0165", + "groups": "C", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "embedded protocol negotiation, not REST" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "bf3f2784f2", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0166", + "groups": "C", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "embedded protocol message" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "99e001b8a5", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0206", + "groups": "C", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "embedded protocol message" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "5023f77e0f", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0207", + "groups": "C", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "embedded protocol message" + }, + { + "file": "docs/specification/shopping/checkout/embedded.md", + "text_digest": "8f97f24d67", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0228", + "groups": "A", + "verdict": "rule", + "actor": "HOST", + "testable": false, + "reason": "aimed at the host" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "369ccf093d", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0007", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on response content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "dec45589b9", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0010", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content when the business revises a quantity" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "8becb2a472", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0013", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "da38167665", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0018", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "bbea25f035", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0020", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on response content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "af51ddc764", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0021", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "68730700a3", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0040", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "message severity in responses" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "f88ead9106", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0044", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "message path in responses" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "a3efff7283", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0045", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "message path in responses" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "90b3974648", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0047", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: completion is blocked until claims resolve" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "ab6a714be7", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0048", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the checkout isn't blocked" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "7ace1fe265", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0051", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: error code eligibility_invalid" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "daf94805c3", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0056", + "groups": "E", + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "defers to each extension's own rules; nothing to check here" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "c00cb541a5", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0058", + "groups": "B", + "verdict": "not a rule", + "actor": "BUSINESS", + "testable": false, + "reason": "narration inside a worked example" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "f1104000fd", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0061", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "2c5d9d6629", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0062", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "16da19e571", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0063", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "3214a8b4f3", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0064", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "f2580192f4", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0065", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "454e178f36", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0066", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "164a7d0bf1", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0067", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "22696563a2", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0068", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "1d6897ff8a", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0069", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "93029fc74c", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0070", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "d8320eb452", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0071", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "Warning Presentation table: how platforms render warnings" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "6f25efb860", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0075", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "rendering contract for platforms" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "0263f18adb", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0081", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "rendering priority for platforms" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "ec3bac66a2", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0093", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "e6f81fd0dd", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0094", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "a1b795b70e", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0095", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "needs a browser handoff; not visible in API responses" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "30d3516026", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0104", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "out-of-band side effect (email delivery); not observable in UCP HTTP responses" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "adbf81349f", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0106", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "architectural principle (deterministic server logic rather than generative computation); observable wire invariants are covered by the totals, line-pricing, and idempotency rules" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "0c5c2c4998", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0117", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "the platform chooses idempotency keys" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "56dd9d5db0", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0118", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "describes how the business may build the order; nothing a test can fail" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "1929627a42", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0120", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: cancel succeeds" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "35b444ee45", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0121", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible in results when no address is given (weakly)" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "e137bb0b98", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0122", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "an internal ranking decision; nothing visible to check" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "d647a85835", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0123", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "about where the business enforces policy; no specific response to check" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "916a488164", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0124", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "platforms provide signals (the extractor read 'buyer')" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "633738379e", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0128", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "9686f34d66", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0129", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "ed6e5e1a5e", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0130", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "78eb4e97bf", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0131", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "debd639454", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0132", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "d725369b04", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0133", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "749321cc43", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0134", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "bcc53c3234", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0135", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "8771b7a275", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0136", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "287b81954f", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0137", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "594b999c87", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0138", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "b43edb9f37", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0139", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "67b450f295", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0140", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "6e36252844", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0141", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "df0becb156", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0142", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "cf4dce95bc", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0143", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "26a6f1432c", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0144", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on totals content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "3ff1a76ae8", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0145", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content", + "note": "same rule as REQ-SHOPPING-CHECKOUT-0132" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "2440b50ae1", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0146", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on totals content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "c933a8a798", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0147", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on totals content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "c49ea1cbba", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0148", + "groups": "AB", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "totals content" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "880a06d004", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0149", + "groups": "A", + "verdict": "not a rule", + "actor": "PLATFORM", + "testable": false, + "reason": "describes the rendering split; the obligations are the platform rendering rules" + }, + { + "file": "docs/specification/shopping/checkout/index.md", + "text_digest": "57a1e5693e", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0150", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/checkout/mcp.md", + "text_digest": "35bccf4f4a", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0233", + "groups": "C", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "MCP binding; the REST page states the same rule" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "017f445b50", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0241", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "binds both sides; the response half is visible" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "86f31bc40b", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0242", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the endpoint's TLS version", + "note": "the local sample server serves plain HTTP, so it fails this" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "2b1505e5e0", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0248", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "about the requests the platform signs" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "833d001a11", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0249", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: response signature headers" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "eb1ea646bd", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0250", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + { + "file": "docs/specification/shopping/checkout/rest.md", + "text_digest": "9655f6d29f", + "id_at_review": "REQ-SHOPPING-CHECKOUT-0251", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "a menu of allowed authentication methods; nothing a test can fail" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "e83d2886ae", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0001", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "c9f256df93", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0002", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "warning messages in responses" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "847433efb5", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0003", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: completion is refused" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "ad6ce21b41", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0004", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "the business surfaces them (the extractor read 'buyer')" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "0a45016c80", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0005", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "completeness against a business's internal consent catalog is not observable over the wire beyond advertising buyer.consent and ignoring unadvertised keys (BUYER-CONSENT-0010)" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "226370a92e", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0006", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "13c85fda79", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0007", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "0251ef1234", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0008", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "4bdc908f46", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0009", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "about the consent map the platform submits (the extractor read 'buyer')" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "7affd65168", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0010", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: unadvertised entries are ignored" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "7918cf85e6", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0011", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "9ea5b9f143", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0012", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "d0e9b52bdd", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0013", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "72244fd689", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0014", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "6b49f63890", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0015", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "40c2df7171", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0016", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/buyer-consent.md", + "text_digest": "047c97c48a", + "id_at_review": "REQ-SHOPPING-BUYER-CONSENT-0017", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "75a607ee1b", + "id_at_review": "REQ-SHOPPING-DISCOUNT-0001", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible in discovery" + }, + { + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "15ac700129", + "id_at_review": "REQ-SHOPPING-DISCOUNT-0002", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "aimed at the platform" + }, + { + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "cf1b7d46ea", + "id_at_review": "REQ-SHOPPING-DISCOUNT-0003", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: codes carried into the checkout" + }, + { + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "99931074ea", + "id_at_review": "REQ-SHOPPING-DISCOUNT-0004", + "groups": "AE", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "messages in responses" + }, + { + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "05ed0d297c", + "id_at_review": "REQ-SHOPPING-DISCOUNT-0005", + "groups": "E", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "warning type in responses" + }, + { + "file": "docs/specification/shopping/extensions/discount.md", + "text_digest": "b7f23c4704", + "id_at_review": "REQ-SHOPPING-DISCOUNT-0009", + "groups": "E", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "completion behavior", + "note": "restates REQ-SHOPPING-CHECKOUT-0047" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "eb39670f05", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0004", + "groups": "A", + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "the MAY is for the method's defining contract" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "3049f1a8c3", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0006", + "groups": "E", + "verdict": "rule", + "actor": "SPEC_AUTHORS", + "testable": false, + "reason": "aimed at future spec revisions and extensions" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "09193f5629", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0007", + "groups": "AE", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "constrains the request" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "62c051ee37", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0011", + "groups": "E", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "about which IDs the platform may send" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "bdf46e29a3", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0012", + "groups": "E", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "ac1221953c", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0013", + "groups": "E", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response content" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "3c15b23155", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0020", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "subjective copywriting quality ('sufficient for buyer decision'); non-empty distinct titles are checked by FULFILLMENT-0018" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "d8d326773b", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0025", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": false, + "reason": "natural-language prose requirement ('standalone sentence explaining what, when, and where'); not machine-verifiable across locales" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "676047abce", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0030", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "'they' refers to 'Platforms' in the first half of the sentence" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "2cf57b7024", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0036", + "groups": "AE", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "'consumers' are platforms" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "443d2106bc", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0037", + "groups": "AE", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "'consumers' are platforms" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "2212f639d3", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0038", + "groups": "AE", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on catalog response content" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "a1a4de15f2", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0040", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "185fc4c8c0", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0041", + "groups": "AE", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on catalog response content" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "ae3b66a72c", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0046", + "groups": "A", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "about the platform profile" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "37e1ff580a", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0047", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + { + "file": "docs/specification/shopping/extensions/fulfillment.md", + "text_digest": "378c4f8068", + "id_at_review": "REQ-SHOPPING-FULFILLMENT-0055", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission; visible when used" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "db110c82c0", + "id_at_review": "REQ-SHOPPING-ORDER-0001", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "order response content" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "5e0b5a836c", + "id_at_review": "REQ-SHOPPING-ORDER-0004", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on order content" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "f650fb481d", + "id_at_review": "REQ-SHOPPING-ORDER-0005", + "groups": "A", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "permission on order content" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "b3887dba91", + "id_at_review": "REQ-SHOPPING-ORDER-0006", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "order adjustment content (measure-priced items only)" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "7e7fe0b12a", + "id_at_review": "REQ-SHOPPING-ORDER-0007", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "order adjustment content (measure-priced items only)" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "d79ebec396", + "id_at_review": "REQ-SHOPPING-ORDER-0012", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platform:'" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "8fb9d0d3c3", + "id_at_review": "REQ-SHOPPING-ORDER-0013", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platform:'" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "e3b0e4d162", + "id_at_review": "REQ-SHOPPING-ORDER-0014", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platform:'" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "af7faa7edc", + "id_at_review": "REQ-SHOPPING-ORDER-0015", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: unauthenticated requests are refused" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "6b50b563f9", + "id_at_review": "REQ-SHOPPING-ORDER-0016", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: webhook signatures (verifying them is the platform's half)" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "f7fb88a8ea", + "id_at_review": "REQ-SHOPPING-ORDER-0020", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platform:'" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "cd10b52eeb", + "id_at_review": "REQ-SHOPPING-ORDER-0021", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "a5e8107f1f", + "id_at_review": "REQ-SHOPPING-ORDER-0022", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "103d1048ca", + "id_at_review": "REQ-SHOPPING-ORDER-0023", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "4b626e6827", + "id_at_review": "REQ-SHOPPING-ORDER-0024", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "1f2d85ce9c", + "id_at_review": "REQ-SHOPPING-ORDER-0025", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + { + "file": "docs/specification/shopping/order/index.md", + "text_digest": "fbd2ccba30", + "id_at_review": "REQ-SHOPPING-ORDER-0026", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "listed under 'Business:'; visible in webhooks" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "de72b2d0de", + "id_at_review": "REQ-SHOPPING-ORDER-0034", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "response bodies" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "86f31bc40b", + "id_at_review": "REQ-SHOPPING-ORDER-0035", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the endpoint's TLS version", + "note": "the local sample server serves plain HTTP, so it fails this" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "15463fa061", + "id_at_review": "REQ-SHOPPING-ORDER-0036", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platforms implementing the REST binding:'" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "c299106814", + "id_at_review": "REQ-SHOPPING-ORDER-0037", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platforms implementing the REST binding:'" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "a6262d6e2e", + "id_at_review": "REQ-SHOPPING-ORDER-0038", + "groups": "B", + "verdict": "rule", + "actor": "PLATFORM", + "testable": false, + "reason": "listed under 'Platforms implementing the REST binding:'" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "10eaedb9f9", + "id_at_review": "REQ-SHOPPING-ORDER-0039", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: the endpoint's TLS version", + "note": "same rule as REQ-SHOPPING-ORDER-0035" + }, + { + "file": "docs/specification/shopping/order/rest.md", + "text_digest": "f797370582", + "id_at_review": "REQ-SHOPPING-ORDER-0040", + "groups": "B", + "verdict": "rule", + "actor": "BUSINESS", + "testable": true, + "reason": "visible: response signature headers" + } + ] +} diff --git a/requirements/tools/build_catalog.py b/requirements/tools/build_catalog.py new file mode 100644 index 0000000..9713573 --- /dev/null +++ b/requirements/tools/build_catalog.py @@ -0,0 +1,2263 @@ +# Copyright 2026 UCP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# /// script +# requires-python = ">=3.10" +# dependencies = [ +# "markdown-it-py==3.0.0", +# "markdown==3.10.2", +# "jsonschema==4.26.0", +# ] +# /// + +"""Build the shopping requirements catalog this suite's markers cite. + +This wraps the requirements extractor from the `.github` repository +(`org-tools/requirements-extractor`) and adds two options the extractor does +not have yet: + +- a capability for every page, from its capability bullet or else its file + path (a preview of the planned file-path rule); and +- counting upper-case RFC 2119 keywords that are not bold (a preview of + counting capitals). + +Every record gains a `suite` object, the fields this repository adds to the +extractor's record: how its capability was found, whether its keyword was +bold, and whether this suite can test it. + +IDs are stable. Each rule's ID comes from `requirements.lock.json`, beside +the catalog, so it no longer changes when a rule is added above it; a +reworded rule keeps its ID, and a removed rule's ID is retired, never +reused. The extractor's positional ID is kept as `suite.positional_id`. + +It also writes `capabilities.json`, an index of the capabilities in the +catalog: whether each is an extension, which capabilities it extends, its +schema and its pages. An extension's parents are read from its schema: the +spec requires a `$defs` entry, keyed by the parent's full name, for every +parent an extension declares. + +Decisions in `requirements/review.json`, made by a person, override the +automatic testability and can mark a rule as not a rule. + +It also records which releases state each rule. `requirements/releases.json` +lists the releases, each at a pinned commit; their shopping pages are read +from a clone of the specification repository and matched to the catalog's +rules by wording, newest release first. Each rule records the releases that +state it, from `suite.since` on. A rule only older releases state is a +removed rule: it gets an ID of its own, retired in the lock, and is written +to `history.json` with `suite.until`, the first version that doesn't state it. + +Usage, from the repository root: + + uv run --no-project requirements/tools/build_catalog.py \ + --spec-root= --spec-commit= \ + --releases-repo= \ + --extractor-dir=<.github checkout>/org-tools/requirements-extractor/scripts + +With `--check`, nothing is written, and the run fails if any output, the +lock included, would change. +""" + +import argparse +import collections +from collections.abc import Callable, Iterator, Mapping, Sequence +import contextlib +import copy +import dataclasses +import difflib +import fnmatch +import hashlib +import importlib +import io +import json +from pathlib import Path, PurePosixPath +import re +import shutil +import subprocess +import sys +import tarfile +import tempfile +from types import ModuleType +from typing import Any + +DOCS_ROOT = PurePosixPath("docs/specification") +SHOPPING_DIR = DOCS_ROOT / "shopping" +REPO_ROOT = Path(__file__).resolve().parents[2] +DEFAULT_OUT_DIR = REPO_ROOT / "requirements" / "catalog" +DEFAULT_REVIEW_FILE = REPO_ROOT / "requirements" / "review.json" +REPORT_FILE = "extraction_report.json" +INDEX_FILE = "capabilities.json" +LOCK_FILE = "requirements.lock.json" +OPTIONS = ("capability-from-bullet-or-path", "count-capitals") + +# Stable IDs: one lock entry per ID ever issued, in ID order. +LOCK_VERSION = 1 +LOCK_ABOUT = ( + "Stable IDs for the shopping requirements catalog: one entry for every ID " + "ever issued. An ID never changes, and a retired ID's number is never " + "issued again. See requirements/README.md." +) +LOCK_FIELDS = ( + "id", + "file", + "text_digest", + "context", + "text", + "previous_digests", + "status", + "minted_at", + "retired_at", +) +LOCK_STATUSES = ("active", "retired") +ID_NUMBER_WIDTH = 4 +# The catalog schema's pattern for a requirement ID. +ID_RE = re.compile(r"^REQ-[A-Z0-9-]+-[0-9]{2,}$") +# How alike a rule's wording must be to that of a rule missing from the same +# page for the two to count as one rule, reworded. +REWORD_SIMILARITY = 0.85 +# The summary lists changed IDs one by one when there are at most this many. +LIST_LIMIT = 20 + +# Release history. +DEFAULT_RELEASES_FILE = REPO_ROOT / "requirements" / "releases.json" +HISTORY_FILE = "history.json" +HISTORY_ABOUT = ( + "Which releases state each rule. A rule in the catalog lists them in " + "suite.releases, from suite.since on. A rule that only older releases state " + "is under removed, with suite.until, the first version that doesn't state " + "it. See requirements/README.md." +) +# The pinned specification's version: newer than every release. +DRAFT = "draft" +# What is read from each release's commit. +RELEASE_PATHS = ("mkdocs.yml", DOCS_ROOT.as_posix(), "source/schemas") +VERSION_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$") +COMMIT_RE = re.compile(r"^[0-9a-f]{40}$") +# A rule is matched on its wording alone, under another list stem or none, +# only when the wording has at least this many words: a cell of the checkout +# obligation matrix reads just "must". +SAME_TEXT_MIN_WORDS = 5 +# How a release's rule matched the next newer version, in the order the +# passes run; and the two outcomes for a rule that matched nothing. +SAME_WORDING = "same wording" +OTHER_PAGE = "same wording, other page" +OTHER_STEM = "same wording, other list stem" +REWORDED = "reworded" +REWORDED_OTHER_PAGE = "reworded, other page" +LAST_STATED = "not stated after this release" +MOVED_OUT = "moved out of the shopping pages" +MATCH_KINDS = ( + SAME_WORDING, + OTHER_PAGE, + OTHER_STEM, + REWORDED, + REWORDED_OTHER_PAGE, + LAST_STATED, + MOVED_OUT, +) + +BOLD_KEYWORD_RE = re.compile( + r"\*\*\s*(?:MUST\s+NOT|MUST|SHALL\s+NOT|SHALL|SHOULD\s+NOT|SHOULD|" + r"NOT\s+RECOMMENDED|RECOMMENDED|REQUIRED|MAY|OPTIONAL)\s*\*\*" +) + +# Whether this suite can test a rule. The suite plays the platform and calls a +# business over REST, so it can check what a business must do on a +# transport-neutral page or the REST binding page, and nothing else. A rule +# with no clear actor counts as testable, so coverage is not overstated. +BINDING_PAGES = { + "rest.md": "rest", + "mcp.md": "mcp", + "a2a.md": "a2a", + "embedded.md": "embedded", +} +UNTESTABLE_TRANSPORTS = { + "mcp": "MCP binding page", + "a2a": "A2A binding page", + "embedded": "embedded protocol page", +} +TESTABLE_ACTORS = { + "BUSINESS": "aimed at the business", + None: "no actor detected", + "IMPLEMENTATION": "implementation guidance", + "EXTENSION": "attributed to the extension", +} +UNTESTABLE_ACTORS = { + "PLATFORM": "aimed at the platform", + "AGENT": "aimed at the agent", + "HOST": "aimed at the host", + "EMBEDDED_CHECKOUT": "aimed at the embedded checkout", + "BUYER": "aimed at the buyer", +} +MUST_LEVELS = ("MUST", "MUST NOT") + + +def testability(record: dict[str, Any]) -> tuple[str, bool | None, str]: + """Return a rule's transport, whether this suite can test it, and why. + + Returns None for testability when the rule's actor is not one this tool + knows, which the caller reports as a problem. + """ + transport = BINDING_PAGES.get( + PurePosixPath(record["source"]["file"]).name, "core" + ) + if transport in UNTESTABLE_TRANSPORTS: + return transport, False, UNTESTABLE_TRANSPORTS[transport] + actor = record["target_actor"] + if actor in UNTESTABLE_ACTORS: + return transport, False, UNTESTABLE_ACTORS[actor] + if actor in TESTABLE_ACTORS: + return transport, True, TESTABLE_ACTORS[actor] + return transport, None, f"unknown actor {actor}" + + +@dataclasses.dataclass(frozen=True) +class PageLabel: + """The capability label of one specification page. + + Attributes: + capabilities: Capability names the page's rules belong to. + source: How the label was found: "bullet", "path", "path (family)" or + "unresolved". + id_name: The name the extractor builds IDs from. For a folder of several + capabilities this is the folder's shared prefix. + + """ + + capabilities: tuple[str, ...] + source: str + id_name: str | None + + +@dataclasses.dataclass(frozen=True) +class CapabilitySchema: + """What a capability's schema says about it. + + Attributes: + file: The schema's path, relative to the spec root. + defs_names: `$defs` keys that are capability names, in schema order. + + """ + + file: str + defs_names: tuple[str, ...] + + +def schema_capabilities(spec_root: Path) -> dict[str, CapabilitySchema]: + """Return every capability a schema in the spec declares, by name.""" + schemas = {} + for path in sorted((spec_root / "source" / "schemas").rglob("*.json")): + try: + document = json.loads(path.read_text(encoding="utf-8")) + except (json.JSONDecodeError, UnicodeDecodeError): + continue + name = document.get("name") if isinstance(document, dict) else None + if isinstance(name, str) and name.startswith("dev.ucp."): + schemas[name] = CapabilitySchema( + file=path.relative_to(spec_root).as_posix(), + defs_names=tuple( + key for key in document.get("$defs", {}) if key.startswith("dev.ucp.") + ), + ) + return schemas + + +def parents_of(name: str, schemas: dict[str, CapabilitySchema]) -> list[str]: + """Return the capabilities an extension extends, from its schema's `$defs`. + + A `$defs` key naming the capability itself is not a parent. + """ + return sorted( + key for key in schemas[name].defs_names if key in schemas and key != name + ) + + +def effective_level(record: dict[str, Any]) -> str | None: + """Return a rule's level, as corrected by the review if it was.""" + return record["suite"].get("review", {}).get("level") or record["level"] + + +def is_active(record: dict[str, Any]) -> bool: + """Whether a rule counts: false when the review found it is not a rule.""" + return not record["suite"].get("excluded") + + +def capability_index( + schemas: dict[str, CapabilitySchema], + labels: dict[str, PageLabel], + records: list[dict[str, Any]], +) -> list[dict[str, Any]]: + """Describe every capability that has rules in the catalog. + + Rules the review found are not rules are left out of every count. + + Args: + schemas: Capabilities declared by the schemas. + labels: Each page's capability label. + records: The catalog's records. + + Returns: + One entry per capability, by name: its kind, the capabilities it + extends and is extended by, its schema, and its pages with their rule + counts. + + """ + records = [r for r in records if is_active(r)] + per_page = collections.Counter(r["source"]["file"] for r in records) + in_scope = sorted({c for r in records for c in r["capabilities"]}) + parents = {name: parents_of(name, schemas) for name in in_scope} + entries = [] + for name in in_scope: + pages = [] + for rel_path in sorted(labels): + label = labels[rel_path] + if name not in label.capabilities or not per_page[rel_path]: + continue + page = {"file": rel_path, "rules": per_page[rel_path]} + shared = [c for c in label.capabilities if c != name] + if shared: + page["shared_with"] = shared + pages.append(page) + own = [r for r in records if name in r["capabilities"]] + testable = [r for r in own if r["suite"]["testable"]] + entries.append( + { + "name": name, + "kind": "extension" if parents[name] else "capability", + "extends": parents[name], + "extended_by": sorted(e for e in in_scope if name in parents[e]), + "schema": schemas[name].file, + "rules": sum(page["rules"] for page in pages), + "testable_rules": len(testable), + "testable_must": sum( + effective_level(r) in MUST_LEVELS for r in testable + ), + "pages": pages, + } + ) + return entries + + +def path_label(rel_path: str, names: set[str]) -> PageLabel: + """Label a page from its file path, with hyphens read as underscores. + + - `/extensions/.md` belongs to `dev.ucp..`; + - a page named after a capability belongs to it + (`shopping/catalog/search.md`); + - a page in a capability's folder belongs to that capability + (`shopping/cart/rest.md`); + - a page in a folder of several capabilities belongs to all of them + (`shopping/catalog/rest.md`). + + Every name produced is one a schema declares. + + Args: + rel_path: Repository-relative POSIX path of the page. + names: Capability names declared by the schemas. + + Returns: + The label, with source "unresolved" when no rule applies. + + """ + parts = [ + part.replace("-", "_") + for part in PurePosixPath(rel_path) + .relative_to(DOCS_ROOT) + .with_suffix("") + .parts + ] + unresolved = PageLabel((), "unresolved", None) + if len(parts) < 3: + return unresolved + vertical, folder, stem = parts[0], parts[1], parts[-1] + if folder == "extensions": + name = f"dev.ucp.{vertical}.{stem}" + if len(parts) == 3 and name in names: + return PageLabel((name,), "path", name) + return unresolved + exact = f"dev.ucp.{vertical}.{folder}.{stem}" + if len(parts) == 3 and exact in names: + return PageLabel((exact,), "path", exact) + folder_name = f"dev.ucp.{vertical}.{folder}" + if folder_name in names: + return PageLabel((folder_name,), "path", folder_name) + family = tuple(sorted(n for n in names if n.startswith(folder_name + "."))) + if family: + return PageLabel(family, "path (family)", folder_name) + return unresolved + + +class SuiteResolver: + """Resolve each page's capability once: the bullet first, then the path.""" + + def __init__( + self, declared: Callable[[Path], str | None], names: set[str] + ) -> None: + """Initialize the resolver. + + Args: + declared: The extractor's reader for a page's capability bullet. + names: Capability names declared by the schemas. + + """ + self._declared = declared + self._names = names + self.labels: dict[str, PageLabel] = {} + self.problems: list[str] = [] + + def __call__(self, rel_path: str, abs_path: Path | None = None) -> str | None: + """Return the name the extractor should build this page's IDs from.""" + if rel_path not in self.labels: + self.labels[rel_path] = self._label(rel_path, abs_path) + return self.labels[rel_path].id_name + + def _label(self, rel_path: str, abs_path: Path | None) -> PageLabel: + declared = self._declared(abs_path) if abs_path is not None else None + from_path = path_label(rel_path, self._names) + if not declared: + return from_path + if declared not in self._names: + self.problems.append( + f"{rel_path}: the bullet names {declared}, which no schema declares" + ) + if from_path.capabilities and declared not in from_path.capabilities: + self.problems.append( + f"{rel_path}: the bullet says {declared} but the file path says " + + ", ".join(from_path.capabilities) + ) + return PageLabel((declared,), "bullet", declared) + + +@contextlib.contextmanager +def replaced(module: ModuleType, name: str, value: Any) -> Iterator[None]: + """Temporarily replace a module attribute.""" + original = getattr(module, name) + setattr(module, name, value) + try: + yield + finally: + setattr(module, name, original) + + +def keyword_style(clause: str) -> str: + """Return "bold" if the clause states its keyword in bold, else "capitals".""" + return "bold" if BOLD_KEYWORD_RE.search(clause) else "capitals" + + +def extractor_tree(extractor_dir: Path) -> Path: + """Return the extractor root when `extractor_dir` points at `scripts/`.""" + resolved = extractor_dir.resolve() + return resolved.parent if resolved.name == "scripts" else resolved + + +def git_commit(path: Path) -> tuple[str, bool]: + """Return the last commit touching `path`, and whether `path` is dirty.""" + commit = subprocess.run( + ["git", "-C", str(path), "log", "-1", "--format=%H", "--", "."], + capture_output=True, + text=True, + check=True, + ).stdout.strip() + status = subprocess.run( + ["git", "-C", str(path), "status", "--porcelain", "--", "."], + capture_output=True, + text=True, + check=True, + ).stdout.strip() + return commit, bool(status) + + +def load_extractor(extractor_dir: Path) -> dict[str, ModuleType]: + """Import the extractor modules from a `.github` checkout.""" + sys.path.insert(0, str(extractor_dir)) + return { + name: importlib.import_module(f"requirements_extractor.{name}") + for name in ("catalog", "classifier", "config", "identity") + } + + +REVIEW_VERDICTS = ("rule", "not a rule") +REVIEW_OPTIONAL = ("level", "note", "needs_your_call") + + +def load_review( + path: Path, problems: list[str] +) -> dict[tuple[str, str], dict[str, Any]]: + """Load review decisions, keyed by page and text digest. + + The digest moves only when a rule's wording does, so a decision survives + ID renumbering and lapses, visibly, when the rule is reworded. A sentence + repeated word for word on one page shares a digest, so its copies share a + key: their decisions must agree. + + Args: + path: The review file; a missing file means no decisions. + problems: Collects malformed entries and conflicting decisions. + + Returns: + The decisions by (file, text_digest). + + """ + if not path.exists(): + return {} + decisions = {} + compared = ("verdict", "actor", "testable", "reason", "level") + for entry in json.loads(path.read_text(encoding="utf-8"))["decisions"]: + key = (entry["file"], entry["text_digest"]) + if entry["verdict"] not in REVIEW_VERDICTS: + problems.append(f"review: unknown verdict for {entry['id_at_review']}") + earlier = decisions.get(key) + if earlier and any(earlier.get(k) != entry.get(k) for k in compared): + problems.append( + f"review: conflicting decisions for repeated wording " + f"({earlier['id_at_review']}, {entry['id_at_review']})" + ) + decisions.setdefault(key, entry) + return decisions + + +def apply_review(record: dict[str, Any], decision: dict[str, Any]) -> None: + """Record a review decision on a rule and let it override testability. + + A rule found not to be a rule stays in the catalog, flagged as excluded, + so the decision is traceable; it is left out of every count. + """ + review = {k: decision[k] for k in ("verdict", "actor", "testable", "reason")} + review.update({k: decision[k] for k in REVIEW_OPTIONAL if k in decision}) + suite = record["suite"] + suite["review"] = review + if decision["verdict"] == "not a rule": + suite["excluded"] = True + suite["testable"] = False + suite["testable_reason"] = "not a rule (reviewed): " + decision["reason"] + else: + suite["testable"] = decision["testable"] + suite["testable_reason"] = "reviewed: " + decision["reason"] + + +@dataclasses.dataclass(frozen=True) +class LockRule: + """What the lock needs to know about one rule. + + Attributes: + prefix: The ID prefix for the rule's page, such as `REQ-SHOPPING-CART`. + file: The rule's page. + text_digest: The rule's text digest. + context: The rule's normalized compound parent, if it has one. + text: The rule's normalized wording. + position: Where the rule sits on its page: its first line, then the + extractor's document order. + + """ + + prefix: str + file: str + text_digest: str + context: str | None + text: str + position: tuple[int, int] + + +@dataclasses.dataclass +class LockResult: + """The outcome of giving every rule a stable ID. + + Attributes: + ids: Each rule's stable ID, in the order the rules were given. + entries: Every lock entry after the run, in ID order. + kept: IDs whose rule was found word for word. + carried: IDs whose rule was found reworded, each with the similarity and + the wording before. + minted: New IDs. + retired: IDs whose rule is gone. + restored: Retired IDs whose rule is back, word for word. + + """ + + ids: list[str] = dataclasses.field(default_factory=list) + entries: list[dict[str, Any]] = dataclasses.field(default_factory=list) + kept: list[str] = dataclasses.field(default_factory=list) + carried: list[tuple[str, float, str]] = dataclasses.field( + default_factory=list + ) + minted: list[str] = dataclasses.field(default_factory=list) + retired: list[str] = dataclasses.field(default_factory=list) + restored: list[str] = dataclasses.field(default_factory=list) + + +def split_id(rule_id: str) -> tuple[str, int]: + """Split a stable ID into its prefix and its number.""" + prefix, _, number = rule_id.rpartition("-") + return prefix, int(number) + + +def match_text(context: str | None, text: str) -> str: + """Return the wording compared when looking for a reworded rule. + + The context is included because the wording alone can be a single word: + the cells of the checkout obligation matrix read "must" or "may". + """ + return f"{context}\n{text}" if context else text + + +def mint_order(rule: LockRule) -> tuple[Any, ...]: + """Return the order new IDs go out in: core page first, then page order.""" + return ( + rule.prefix, + PurePosixPath(rule.file).name != "index.md", + rule.file, + rule.position, + ) + + +def assign_stable_ids( + rules: list[LockRule], lock: list[dict[str, Any]], spec_commit: str +) -> LockResult: + """Give every rule a stable ID from the lock, issuing new IDs as needed. + + Four passes: + + 1. Exact: a rule takes the ID of an entry on the same page with the same + text digest. Copies of one sentence on a page take that wording's IDs + oldest first, in page order. A retired entry can match, which restores + its ID. + 2. Reworded: a rule still without an ID takes the ID of an unclaimed + active entry on the same page whose wording is at least + `REWORD_SIMILARITY` alike, the most alike pairs first. The entry keeps + its old digest in `previous_digests`. + 3. New: every rule still without an ID gets the next number for its + prefix, in `mint_order`. + 4. Retired: an active entry no rule claimed is retired. Its number is + never issued again. + + Args: + rules: The catalog's rules. + lock: The lock's entries. They are not modified. + spec_commit: The specification commit, recorded on new and retired + entries. + + Returns: + The IDs, the updated entries and what changed. + + """ + entries = {entry["id"]: copy.deepcopy(entry) for entry in lock} + ids: list[str | None] = [None] * len(rules) + claimed: set[str] = set() + result = LockResult() + page_order = sorted( + range(len(rules)), key=lambda i: (rules[i].file, rules[i].position) + ) + + # 1. Exact. + by_wording = collections.defaultdict(list) + for rule_id in sorted(entries, key=split_id): + entry = entries[rule_id] + by_wording[entry["file"], entry["text_digest"]].append(rule_id) + for i in page_order: + for rule_id in by_wording[rules[i].file, rules[i].text_digest]: + if rule_id in claimed: + continue + claimed.add(rule_id) + ids[i] = rule_id + entry = entries[rule_id] + if entry["status"] == "retired": + entry["status"], entry["retired_at"] = "active", None + result.restored.append(rule_id) + else: + result.kept.append(rule_id) + break + + # 2. Reworded. + open_entries = collections.defaultdict(list) + for rule_id in sorted(entries, key=split_id): + entry = entries[rule_id] + if rule_id not in claimed and entry["status"] == "active": + open_entries[entry["file"]].append(rule_id) + pairs = [] + for rank, i in enumerate(page_order): + if ids[i] is not None: + continue + wording = match_text(rules[i].context, rules[i].text) + for rule_id in open_entries[rules[i].file]: + entry = entries[rule_id] + matcher = difflib.SequenceMatcher( + None, + match_text(entry["context"], entry["text"]), + wording, + autojunk=False, + ) + if ( + matcher.real_quick_ratio() >= REWORD_SIMILARITY + and matcher.quick_ratio() >= REWORD_SIMILARITY + and (similarity := matcher.ratio()) >= REWORD_SIMILARITY + ): + pairs.append((-similarity, split_id(rule_id), rank, i, rule_id)) + for negative_similarity, _, _, i, rule_id in sorted(pairs): + if ids[i] is not None or rule_id in claimed: + continue + claimed.add(rule_id) + ids[i] = rule_id + entry = entries[rule_id] + result.carried.append((rule_id, -negative_similarity, entry["text"])) + entry["previous_digests"].append(entry["text_digest"]) + entry["text_digest"] = rules[i].text_digest + entry["context"] = rules[i].context + entry["text"] = rules[i].text + + # 3. New. + highest: collections.Counter[str] = collections.Counter() + for rule_id in entries: + prefix, number = split_id(rule_id) + highest[prefix] = max(highest[prefix], number) + unmatched = [i for i in range(len(rules)) if ids[i] is None] + for i in sorted(unmatched, key=lambda i: mint_order(rules[i])): + rule = rules[i] + highest[rule.prefix] += 1 + rule_id = f"{rule.prefix}-{highest[rule.prefix]:0{ID_NUMBER_WIDTH}d}" + entries[rule_id] = { + "id": rule_id, + "file": rule.file, + "text_digest": rule.text_digest, + "context": rule.context, + "text": rule.text, + "previous_digests": [], + "status": "active", + "minted_at": spec_commit, + "retired_at": None, + } + claimed.add(rule_id) + ids[i] = rule_id + result.minted.append(rule_id) + + # 4. Retired. + for rule_id in sorted(entries, key=split_id): + entry = entries[rule_id] + if rule_id not in claimed and entry["status"] == "active": + entry["status"], entry["retired_at"] = "retired", spec_commit + result.retired.append(rule_id) + + result.ids = [rule_id or "" for rule_id in ids] + result.entries = [entries[k] for k in sorted(entries, key=split_id)] + return result + + +def load_lock( + path: Path, + digest_of: Callable[[str | None, str], str], + problems: list[str], +) -> list[dict[str, Any]]: + """Load the lock's entries and check that they are well formed. + + Args: + path: The lock file. A missing file means no ID has been issued yet. + digest_of: Computes a text digest from a context and a wording. + problems: Collects anything malformed. + + Returns: + The entries, as stored. + + """ + if not path.exists(): + return [] + document = json.loads(path.read_text(encoding="utf-8")) + if document.get("lock_version") != LOCK_VERSION: + problems.append( + f"lock: unsupported lock_version {document.get('lock_version')!r}" + ) + return [] + entries = document.get("entries", []) + seen = set() + for entry in entries: + rule_id = str(entry.get("id")) + if sorted(entry) != sorted(LOCK_FIELDS): + problems.append(f"lock: {rule_id} does not have the expected fields") + continue + if not ID_RE.match(rule_id) or rule_id in seen: + problems.append(f"lock: {rule_id} is malformed or repeated") + seen.add(rule_id) + retired = entry["status"] == "retired" + if entry["status"] not in LOCK_STATUSES or retired != bool( + entry["retired_at"] + ): + problems.append(f"lock: {rule_id} has an inconsistent status") + if digest_of(entry["context"], entry["text"]) != entry["text_digest"]: + problems.append(f"lock: {rule_id}'s wording does not match its digest") + return entries + + +def lock_problems(lock: list[dict[str, Any]], result: LockResult) -> list[str]: + """Check what giving out stable IDs must never do. + + Every ID ever issued stays in the lock; a new ID's number is above every + number its prefix has used, retired ones included; and every rule has an + ID that fits the catalog schema's pattern and an active entry of its own. + """ + problems = [] + dropped = sorted({e["id"] for e in lock} - {e["id"] for e in result.entries}) + if dropped: + problems.append(f"lock: IDs dropped: {dropped[:5]}") + highest: collections.Counter[str] = collections.Counter() + for entry in lock: + prefix, number = split_id(entry["id"]) + highest[prefix] = max(highest[prefix], number) + reused = [ + rule_id + for rule_id in result.minted + if split_id(rule_id)[1] <= highest[split_id(rule_id)[0]] + ] + if reused: + problems.append(f"lock: numbers issued again: {reused[:5]}") + malformed = [rule_id for rule_id in result.ids if not ID_RE.match(rule_id)] + if malformed: + problems.append(f"IDs that do not fit the schema: {malformed[:5]}") + active = sum(entry["status"] == "active" for entry in result.entries) + if active != len(result.ids): + problems.append(f"lock: {active} active IDs for {len(result.ids)} rules") + return problems + + +def lock_document(entries: list[dict[str, Any]]) -> dict[str, Any]: + """Return the lock file's contents, each entry's fields in a fixed order.""" + return { + "about": LOCK_ABOUT, + "lock_version": LOCK_VERSION, + "entries": [{field: e[field] for field in LOCK_FIELDS} for e in entries], + } + + +def without_suite(document: dict[str, Any]) -> dict[str, Any]: + """Return a catalog document without the suite's additions.""" + return { + **{k: v for k, v in document.items() if k != "suite"}, + "requirements": [ + {k: v for k, v in record.items() if k != "suite"} + for record in document["requirements"] + ], + } + + +@dataclasses.dataclass +class Extraction: + """What one run of the extractor found in a specification. + + Attributes: + schemas: The capabilities the specification's schemas declare. + resolver: Each page's capability label, and problems found labelling. + documents: One catalog document per page, by output path. + report_document: The extractor's report. + bold_only: The rules found when only bold keywords count, if asked for. + + """ + + schemas: dict[str, CapabilitySchema] + resolver: SuiteResolver + documents: dict[Any, dict[str, Any]] + report_document: dict[str, Any] + bold_only: list[Any] + + +def extract( + modules: dict[str, ModuleType], + spec_root: Path, + spec_dir: PurePosixPath, + *, + bold_only: bool = False, +) -> Extraction: + """Run the extractor over one folder of a specification. + + With the suite's two options: every page gets a capability from its bullet + or its file path, and upper-case keywords count whether bold or not. + + Args: + modules: The extractor's modules. + spec_root: The specification checkout. + spec_dir: The folder to read, relative to `spec_root`. + bold_only: Also run counting only bold keywords, as the extractor does. + + Returns: + What the extractor found. + + """ + catalog, classifier, config = ( + modules["catalog"], + modules["classifier"], + modules["config"], + ) + schemas = schema_capabilities(spec_root) + resolver = SuiteResolver(config.declared_capability, set(schemas)) + original_find = classifier.find_keywords + + def find_all_keywords(text: str, keywords: tuple[str, ...]) -> list[Any]: + return [ + dataclasses.replace(hit, bolded=True) + for hit in original_find(text, keywords) + ] + + with ( + replaced(config, "SPEC_DIRS", [Path(spec_dir)]), + replaced(config, "resolve_capability", resolver), + ): + bold = catalog.build(spec_root)[0] if bold_only else [] + with replaced(classifier, "find_keywords", find_all_keywords): + requirements, report = catalog.build(spec_root) + documents = catalog.catalog_documents(requirements, report, spec_root) + report_document = catalog.report_document(requirements, report, spec_root) + return Extraction(schemas, resolver, documents, report_document, bold) + + +def annotate(record: dict[str, Any], label: PageLabel) -> None: + """Give a rule its page's capabilities and the suite's `suite` object.""" + if record["capabilities"]: + record["capabilities"] = list(label.capabilities) + transport, testable, reason = testability(record) + record["suite"] = { + "positional_id": record["id"], + "capability_source": label.source, + "keyword_style": keyword_style(record["clause"]), + "transport": transport, + "testable": testable, + "testable_reason": reason, + } + + +def in_shopping(file: str) -> bool: + """Return whether a page is in the shopping folder.""" + return file.startswith(f"{SHOPPING_DIR}/") + + +@dataclasses.dataclass(frozen=True) +class Release: + """A release of the specification, read at a pinned commit. + + Attributes: + version: The release, such as "2026-04-08". + ref: The branch it was pinned from. + commit: The commit it is read at. + + """ + + version: str + ref: str + commit: str + + +@dataclasses.dataclass(frozen=True) +class ReleaseConfig: + """The releases the history is read from, and where their pages are. + + Attributes: + releases: The releases, oldest first. + flat_pages: For a release without a shopping folder, each shopping + page's path today, by its path in the release; both relative to the + specification's docs. + other_pages: Patterns for that release's pages outside the shopping + vertical. + + """ + + releases: tuple[Release, ...] = () + flat_pages: Mapping[str, str] = dataclasses.field(default_factory=dict) + other_pages: tuple[str, ...] = () + + @property + def versions(self) -> tuple[str, ...]: + """Return every version, oldest first: the releases, then the draft.""" + return (*(release.version for release in self.releases), DRAFT) + + +def load_releases(path: Path, problems: list[str]) -> ReleaseConfig: + """Load the releases the history is read from, and check them. + + Args: + path: The releases file. + problems: Collects anything malformed. + + Returns: + The releases and the page map; none when the file can't be read. + + """ + try: + document = json.loads(path.read_text(encoding="utf-8")) + config = ReleaseConfig( + releases=tuple( + Release(entry["version"], entry["ref"], entry["commit"]) + for entry in document["releases"] + ), + flat_pages=dict(document["flat_pages"]), + other_pages=tuple(document["other_pages"]), + ) + except (OSError, json.JSONDecodeError, KeyError, TypeError) as error: + problems.append(f"releases: cannot read {path}: {error}") + return ReleaseConfig() + versions = [release.version for release in config.releases] + if not all(VERSION_RE.match(v) for v in versions) or versions != sorted( + set(versions) + ): + problems.append( + f"releases: versions must be distinct dates, oldest first: {versions}" + ) + short = [r.version for r in config.releases if not COMMIT_RE.match(r.commit)] + if short: + problems.append(f"releases: commits must be full hashes: {short}") + elsewhere = sorted( + page + for page in config.flat_pages.values() + if not page.startswith(f"{SHOPPING_DIR.name}/") + ) + if elsewhere: + problems.append( + f"releases: flat pages mapped outside the shopping folder: {elsewhere}" + ) + return config + + +def load_splits(path: Path, problems: list[str]) -> dict[str, str]: + """Load the review's splits: older wordings found to be other rules. + + A split says that releases before a version state another rule in the + wording that matched an ID. That wording becomes a removed rule of its + own, and the ID's history starts at the version. + + Args: + path: The review file; a missing file, or one without splits, has none. + problems: Collects malformed splits. + + Returns: + For each split ID, the first version whose wording is that rule. + + """ + if not path.exists(): + return {} + splits: dict[str, str] = {} + document = json.loads(path.read_text(encoding="utf-8")) + for entry in document.get("splits", []): + rule_id, first = entry.get("id"), entry.get("before") + if ( + not isinstance(rule_id, str) + or not ID_RE.match(rule_id) + or rule_id in splits + or not (first == DRAFT or VERSION_RE.match(str(first))) + or not entry.get("reason") + ): + problems.append(f"review: malformed split {entry!r}") + continue + splits[rule_id] = first + return splits + + +def stage_release( + repo: Path, release: Release, config: ReleaseConfig, dest: Path +) -> tuple[dict[str, str], list[str]]: + """Write a release's pages and schemas, shopping pages at today's paths. + + A release with a shopping folder is written as it is. In one without, each + page in `config.flat_pages` moves to its path today, so its rules get the + capability and testability the pinned specification's page gives them. + + Args: + repo: A clone of the specification repository with the release's commit. + release: The release. + config: The page map. + dest: An empty directory to write to. + + Returns: + Each moved page's path in the release, by its path today; and the + release's pages that are neither in the page map nor other pages. + + Raises: + subprocess.CalledProcessError: If the clone doesn't have the commit. + + """ + archive = subprocess.run( + [ + "git", + "-C", + str(repo), + "archive", + "--format=tar", + release.commit, + *RELEASE_PATHS, + ], + capture_output=True, + check=True, + ).stdout + with tarfile.open(fileobj=io.BytesIO(archive)) as tar: + tar.extractall(dest, filter="data") + docs = dest / DOCS_ROOT + if (docs / SHOPPING_DIR.name).is_dir(): + return {}, [] + moved: dict[str, str] = {} + unknown: list[str] = [] + for path in sorted(docs.rglob("*.md")): + page = path.relative_to(docs).as_posix() + if page in config.flat_pages: + target = docs / config.flat_pages[page] + target.parent.mkdir(parents=True, exist_ok=True) + path.rename(target) + moved[(DOCS_ROOT / config.flat_pages[page]).as_posix()] = ( + DOCS_ROOT / page + ).as_posix() + elif not any( + fnmatch.fnmatchcase(page, pattern) for pattern in config.other_pages + ): + unknown.append(page) + return moved, unknown + + +@dataclasses.dataclass(frozen=True) +class Wording: + """A rule's wording, as the history compares it. + + Attributes: + file: The rule's page, at its path in the pinned specification. + text_digest: The digest of its context and wording. + context: Its normalized compound parent, if it has one. + text: Its normalized wording. + + """ + + file: str + text_digest: str + context: str | None + text: str + + @property + def compared(self) -> str: + """Return what is compared to find a rewording.""" + return match_text(self.context, self.text) + + +def wording_of( + record: dict[str, Any], normalize: Callable[[str], str] +) -> Wording: + """Return the wording of an extracted rule.""" + parent = record["compound_parent"] + return Wording( + file=record["source"]["file"], + text_digest=record["text_digest"], + context=normalize(parent) if parent else None, + text=record["normalized"], + ) + + +@dataclasses.dataclass(frozen=True) +class Stated: + """A rule as one release states it. + + Attributes: + version: The release. + wording: The rule's wording, with its page at the path it has today. + position: Where it sits on its page: its first line, then the + extractor's document order. + file: Its page, at the path the release gives it. + level: Its level, as corrected by the review if it was. + prefix: The ID prefix for its page. + record: Its catalog record from the release. + + """ + + version: str + wording: Wording + position: tuple[int, int] + file: str + level: str + prefix: str + record: dict[str, Any] = dataclasses.field( + default_factory=dict, compare=False, repr=False + ) + + +def similarity(before: str, after: str) -> float: + """Return how alike two wordings are, or 0 under `REWORD_SIMILARITY`.""" + matcher = difflib.SequenceMatcher(None, before, after, autojunk=False) + if ( + matcher.real_quick_ratio() < REWORD_SIMILARITY + or matcher.quick_ratio() < REWORD_SIMILARITY + ): + return 0.0 + ratio = matcher.ratio() + return ratio if ratio >= REWORD_SIMILARITY else 0.0 + + +def match_release( + stated: Sequence[Stated], + candidates: Mapping[str, Wording], + related: Callable[[str, str], bool] | None = None, +) -> list[tuple[str, str] | None]: + """Match a release's rules to the rules of the next newer version. + + Five passes, each giving a rule at most one candidate and a candidate at + most one rule; rules go in page order and candidates in key order: + + 1. the same wording on the same page; + 2. the same wording on another, related page, for a rule that moved; + 3. the same wording under another list stem, or none, on the same page, + for a wording of at least `SAME_TEXT_MIN_WORDS` words; + 4. a wording at least `REWORD_SIMILARITY` alike on the same page, most + alike first; + 5. the same, on another related page. + + Args: + stated: The release's rules. + candidates: The rules of newer versions, by key, each with its wording + in the next newer version that states it. + related: Whether a rule can move between two pages, such as two pages + of one capability. By default it can move between any two. + + Returns: + For each of the release's rules, the key it matched and how, or None. + + """ + found: list[tuple[str, str] | None] = [None] * len(stated) + claimed: set[str] = set() + order = sorted( + range(len(stated)), + key=lambda i: (stated[i].wording.file, stated[i].position), + ) + keys = sorted(candidates) + + def take(i: int, key: str, kind: str) -> None: + found[i] = (key, kind) + claimed.add(key) + + def allowed(key: str, wording: Wording, same_page: bool) -> bool: + page = candidates[key].file + if same_page: + return page == wording.file + return page != wording.file and ( + related is None or related(page, wording.file) + ) + + by_digest = collections.defaultdict(list) + for key in keys: + by_digest[candidates[key].text_digest].append(key) + for same_page, kind in ((True, SAME_WORDING), (False, OTHER_PAGE)): + for i in order: + if found[i] is not None: + continue + wording = stated[i].wording + for key in by_digest[wording.text_digest]: + if key not in claimed and allowed(key, wording, same_page): + take(i, key, kind) + break + for i in order: + wording = stated[i].wording + if found[i] is not None or len(wording.text.split()) < SAME_TEXT_MIN_WORDS: + continue + for key in keys: + if ( + key not in claimed + and allowed(key, wording, same_page=True) + and candidates[key].text == wording.text + ): + take(i, key, OTHER_STEM) + break + compared = {key: candidates[key].compared for key in keys} + for same_page, kind in ((True, REWORDED), (False, REWORDED_OTHER_PAGE)): + pairs = [] + for rank, i in enumerate(order): + if found[i] is not None: + continue + wording = stated[i].wording + for key in keys: + if key in claimed or not allowed(key, wording, same_page): + continue + alike = similarity(compared[key], wording.compared) + if alike: + pairs.append((-alike, key, rank, i)) + for _, key, _, i in sorted(pairs): + if found[i] is None and key not in claimed: + take(i, key, kind) + return found + + +def moved_to(wording: Wording, outside: Sequence[Wording]) -> list[str]: + """Return the pages outside the shopping pages that state a wording now. + + Every page with the same wording counts; failing that, the page of the + most alike wording, if one is at least `REWORD_SIMILARITY` alike. + + Args: + wording: A release's rule that no newer shopping rule matched. + outside: The rules the pinned specification states outside the + shopping pages. + + Returns: + The pages, in path order; empty if none states the wording. + + """ + long_enough = len(wording.text.split()) >= SAME_TEXT_MIN_WORDS + same = { + other.file + for other in outside + if other.text_digest == wording.text_digest + or (long_enough and other.text == wording.text) + } + if same: + return sorted(same) + alike, page = max( + ( + (similarity(other.compared, wording.compared), other.file) + for other in outside + ), + default=(0.0, ""), + ) + return [page] if alike else [] + + +@dataclasses.dataclass +class History: + """Which releases state each rule. + + Attributes: + stated: For each rule, how each release that states it states it, + oldest first. A rule of the pinned specification is keyed by its ID; + a removed rule by its key in `removed`. + matched: For each release, how many of its rules matched each way, by + the kinds in `MATCH_KINDS`. + removed: The keys of rules no newer version states, in the order found: + newest release first. + moved_out: Rules of a release that the pinned specification states + outside the shopping pages, each with the pages that state it now. + reworded: Matches on a reworded wording, for a person to check: the + release's rule, the key it matched, the newer wording, and how alike + the two are. + split: The IDs whose split took effect. + + """ + + stated: dict[str, list[Stated]] = dataclasses.field( + default_factory=lambda: collections.defaultdict(list) + ) + matched: dict[str, collections.Counter[str]] = dataclasses.field( + default_factory=dict + ) + removed: list[str] = dataclasses.field(default_factory=list) + moved_out: list[tuple[Stated, list[str]]] = dataclasses.field( + default_factory=list + ) + reworded: list[tuple[Stated, str, Wording, float]] = dataclasses.field( + default_factory=list + ) + split: set[str] = dataclasses.field(default_factory=set) + + +def trace_history( + versions: Sequence[str], + stated: Mapping[str, Sequence[Stated]], + current: Mapping[str, Wording], + outside: Sequence[Wording], + splits: Mapping[str, str] | None = None, + related: Callable[[str, str], bool] | None = None, +) -> History: + """Trace the catalog's rules back through the releases, newest first. + + Each release's rules are matched by `match_release` to the wording each + rule has in the next newer version that states it, starting with the + pinned specification. A rule that matches none moved out of the shopping + pages if the pinned specification states it outside them. Otherwise it is + a removed rule, which older releases are matched to in turn. + + Args: + versions: Every version, oldest first, ending with `DRAFT`. + stated: Each release's rules, by version. + current: The wording of each rule of the pinned specification, by ID. + outside: The rules the pinned specification states outside the + shopping pages. + splits: For an ID whose older wording the review found is another rule, + the first version whose wording is this rule. + related: Whether a rule can move between two pages; see + `match_release`. + + Returns: + The history. + + """ + splits = splits or {} + history = History() + candidates = dict(current) + for version in reversed(versions[:-1]): + index = versions.index(version) + blocked = { + rule_id + for rule_id, first in splits.items() + if index < versions.index(first) and rule_id in candidates + } + rules = stated[version] + found = match_release( + rules, + {key: w for key, w in candidates.items() if key not in blocked}, + related, + ) + counts: collections.Counter[str] = collections.Counter() + keyed: list[tuple[Stated, str]] = [] + for rule, match in zip(rules, found, strict=True): + if match is None: + pages = moved_to(rule.wording, outside) + if pages: + history.moved_out.append((rule, pages)) + counts[MOVED_OUT] += 1 + continue + key, kind = f"~{len(history.removed):05d}", LAST_STATED + history.removed.append(key) + else: + key, kind = match + counts[kind] += 1 + if kind in (REWORDED, REWORDED_OTHER_PAGE): + newer = candidates[key] + alike = similarity(newer.compared, rule.wording.compared) + history.reworded.append((rule, key, newer, alike)) + keyed.append((rule, key)) + for rule_id in blocked: + if index + 1 == versions.index(splits[rule_id]) and any( + match_release(rules, {rule_id: candidates[rule_id]}, related) + ): + history.split.add(rule_id) + for rule, key in keyed: + history.stated[key].insert(0, rule) + candidates[key] = rule.wording + history.matched[version] = counts + return history + + +def stated_order(stated: Stated) -> tuple[Any, ...]: + """Return the order new IDs go out in: core page first, then page order.""" + file = stated.wording.file + return ( + stated.prefix, + PurePosixPath(file).name != "index.md", + file, + stated.position, + ) + + +def assign_removed_ids( + removed: Sequence[Sequence[Stated]], + entries: Sequence[dict[str, Any]], + spec_commit: str, +) -> tuple[list[str], list[dict[str, Any]], list[str]]: + """Give each removed rule a stable ID. + + A removed rule takes the ID of a retired lock entry that has one of its + wordings, on its newest page first; failing that, of one whose wording is + at least `REWORD_SIMILARITY` alike to its newest, most alike first. + Otherwise it gets the next number for its prefix, in a new entry retired + from the start: the pinned specification doesn't state it. Rules go in + the order `stated_order` gives their newest statements. + + Args: + removed: Each removed rule's statements, oldest first. + entries: The lock's entries. They are not modified. + spec_commit: The pinned specification's commit, for new entries. + + Returns: + Each removed rule's ID; the lock's entries after, in ID order; and the + new IDs. + + """ + entries = [copy.deepcopy(entry) for entry in entries] + retired = sorted( + (entry for entry in entries if entry["status"] == "retired"), + key=lambda entry: split_id(entry["id"]), + ) + ids: list[str | None] = [None] * len(removed) + claimed: set[str] = set() + order = sorted( + range(len(removed)), key=lambda i: stated_order(removed[i][-1]) + ) + for same_page in (True, False): + for i in order: + if ids[i] is not None: + continue + newest = removed[i][-1].wording + digests = {statement.wording.text_digest for statement in removed[i]} + for entry in retired: + known = {entry["text_digest"], *entry["previous_digests"]} + on_page = entry["file"] == newest.file + if ( + entry["id"] not in claimed + and on_page == same_page + and digests & known + ): + ids[i] = entry["id"] + claimed.add(entry["id"]) + break + for same_page in (True, False): + pairs = [] + for rank, i in enumerate(order): + if ids[i] is not None: + continue + newest = removed[i][-1].wording + for entry in retired: + on_page = entry["file"] == newest.file + if entry["id"] in claimed or on_page != same_page: + continue + alike = similarity( + match_text(entry["context"], entry["text"]), newest.compared + ) + if alike: + pairs.append((-alike, split_id(entry["id"]), rank, i, entry["id"])) + for *_, i, rule_id in sorted(pairs): + if ids[i] is None and rule_id not in claimed: + ids[i] = rule_id + claimed.add(rule_id) + highest: collections.Counter[str] = collections.Counter() + for entry in entries: + prefix, number = split_id(entry["id"]) + highest[prefix] = max(highest[prefix], number) + minted = [] + for i in order: + if ids[i] is not None: + continue + newest = removed[i][-1] + highest[newest.prefix] += 1 + rule_id = f"{newest.prefix}-{highest[newest.prefix]:0{ID_NUMBER_WIDTH}d}" + older = [statement.wording.text_digest for statement in removed[i][:-1]] + entries.append( + { + "id": rule_id, + "file": newest.wording.file, + "text_digest": newest.wording.text_digest, + "context": newest.wording.context, + "text": newest.wording.text, + "previous_digests": [ + digest + for digest in dict.fromkeys(older) + if digest != newest.wording.text_digest + ], + "status": "retired", + "minted_at": spec_commit, + "retired_at": spec_commit, + } + ) + ids[i] = rule_id + minted.append(rule_id) + entries.sort(key=lambda entry: split_id(entry["id"])) + return [rule_id or "" for rule_id in ids], entries, minted + + +def lifespan( + stated_in: Sequence[str], versions: Sequence[str] +) -> tuple[str, str | None]: + """Return a rule's first version, and the first version after its last. + + Args: + stated_in: The versions that state the rule, oldest first. + versions: Every version, oldest first, ending with `DRAFT`. + + Returns: + `since` and `until`; `until` is None while the draft states the rule. + + """ + last = versions.index(stated_in[-1]) + until = versions[last + 1] if last + 1 < len(versions) else None + return stated_in[0], until + + +def statements( + stated: Sequence[Stated], own_digest: str +) -> list[dict[str, Any]]: + """Describe how each release states a rule, oldest first. + + Each entry gives the release; the page and line as the release has them; + the level and the wording's digest; and the wording itself when it isn't + the record's own. + """ + entries = [] + for statement in stated: + entry = { + "version": statement.version, + "file": statement.file, + "start_line": statement.position[0], + "level": statement.level, + "text_digest": statement.wording.text_digest, + } + if statement.wording.text_digest != own_digest: + entry["clause"] = statement.record["clause"] + entries.append(entry) + return entries + + +def removed_record( + stated: Sequence[Stated], + rule_id: str, + versions: Sequence[str], + published_page: Callable[[str], str], +) -> dict[str, Any]: + """Return the record of a rule that only older releases state. + + It is the newest release's record, at that release's page, with the + rule's stable ID and its history in `suite`. + """ + newest = stated[-1] + record = copy.deepcopy(newest.record) + record["id"] = rule_id + record["source"]["file"] = newest.file + record["source"]["page"] = published_page(newest.file) + since, until = lifespan([statement.version for statement in stated], versions) + record["suite"]["since"] = since + record["suite"]["until"] = until + record["suite"]["releases"] = statements(stated, record["text_digest"]) + return record + + +def main(argv: list[str] | None = None) -> int: + """Build the catalog, write it, and print a summary.""" + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + parser.add_argument("--spec-root", type=Path, required=True) + parser.add_argument("--spec-commit", required=True) + parser.add_argument("--extractor-dir", type=Path, required=True) + parser.add_argument( + "--releases-repo", + type=Path, + required=True, + help="a clone of the specification repository with the release commits", + ) + parser.add_argument("--releases", type=Path, default=DEFAULT_RELEASES_FILE) + parser.add_argument("--out-dir", type=Path, default=DEFAULT_OUT_DIR) + parser.add_argument("--review", type=Path, default=DEFAULT_REVIEW_FILE) + parser.add_argument( + "--check", + action="store_true", + help="write nothing; fail if any output, the lock included, would change", + ) + args = parser.parse_args(argv) + spec_root = args.spec_root.resolve() + out_dir = args.out_dir.resolve() + out = sys.stdout.write + + modules = load_extractor(args.extractor_dir.resolve()) + catalog, config, identity = ( + modules["catalog"], + modules["config"], + modules["identity"], + ) + extractor_commit, extractor_dirty = git_commit( + extractor_tree(args.extractor_dir) + ) + pinned = extract(modules, spec_root, SHOPPING_DIR, bold_only=True) + schemas, resolver = pinned.schemas, pinned.resolver + names = set(schemas) + documents = pinned.documents + report_document = pinned.report_document + bold_only = pinned.bold_only + + suite_header = { + "spec_commit": args.spec_commit, + "extractor_commit": extractor_commit, + "options": list(OPTIONS), + "ids": f"stable, from {LOCK_FILE}", + } + review_problems: list[str] = [] + reviews = load_review(args.review.resolve(), review_problems) + used_reviews = set() + pre_review = {} + records = [] + for path, document in documents.items(): + label = resolver.labels[document["source_file"]] + for record in document["requirements"]: + annotate(record, label) + pre_review[record["id"]] = (record["suite"]["testable"], record["level"]) + key = (record["source"]["file"], record["text_digest"]) + if key in reviews: + used_reviews.add(key) + apply_review(record, reviews[key]) + records.append(record) + documents[path] = dict( + [ + *[(k, v) for k, v in document.items() if k != "requirements"], + ("suite", suite_header), + ("requirements", document["requirements"]), + ] + ) + + # Stable IDs. A malformed lock stops the run before anything is written. + def digest_of(context: str | None, text: str) -> str: + joined = identity.DIGEST_SEPARATOR.join((context or "", text)) + digest = hashlib.sha256(joined.encode("utf-8")).hexdigest() + return digest[: config.ID_DIGEST_LENGTH] + + def prefix_of(labels: dict[str, PageLabel], file: str) -> str: + slug = config.capability_slug(labels[file].id_name) + return f"{config.READABLE_ID_PREFIX}-{slug}" + + lock_path = out_dir / LOCK_FILE + lock_load_problems: list[str] = [] + lock = load_lock(lock_path, digest_of, lock_load_problems) + if lock_load_problems: + out("PROBLEMS:\n" + "".join(f" - {p}\n" for p in lock_load_problems)) + return 1 + rules = [ + LockRule( + prefix=prefix_of(resolver.labels, r["source"]["file"]), + file=r["source"]["file"], + text_digest=r["text_digest"], + context=identity.normalize(r["compound_parent"]) + if r["compound_parent"] + else None, + text=r["normalized"], + position=(r["source"]["start_line"], r["document_order"]), + ) + for r in records + ] + assigned = assign_stable_ids(rules, lock, args.spec_commit) + for record, stable_id in zip(records, assigned.ids, strict=True): + record["id"] = stable_id + stable_ids = {r["suite"]["positional_id"]: r["id"] for r in records} + for entry in report_document["diagnostics"].get("duplicate_requirements", []): + entry["ids"] = [stable_ids.get(i, i) for i in entry["ids"]] + + # Release history: read each release, trace the rules back through them, + # and give removed rules IDs of their own. + history_problems: list[str] = [] + releases = load_releases(args.releases.resolve(), history_problems) + splits = load_splits(args.review.resolve(), history_problems) + versions = releases.versions + everything = extract(modules, spec_root, DOCS_ROOT) + outside = [ + wording_of(record, identity.normalize) + for document in everything.documents.values() + for record in document["requirements"] + if not in_shopping(record["source"]["file"]) + ] + stated_by_version: dict[str, list[Stated]] = {} + page_capabilities: dict[str, set[str]] = collections.defaultdict(set) + for file, label in resolver.labels.items(): + page_capabilities[file].update(label.capabilities) + for release in releases.releases: + with tempfile.TemporaryDirectory() as staging: + root = Path(staging) + try: + moved, unknown = stage_release( + args.releases_repo.resolve(), release, releases, root + ) + except subprocess.CalledProcessError as error: + out( + f"PROBLEMS:\n - release {release.version}: cannot read commit " + f"{release.commit[:8]} from {args.releases_repo}: " + f"{error.stderr.decode(errors='replace').strip()}\n" + ) + return 1 + found = extract(modules, root, DOCS_ROOT) + declared = config.spec_version(root) + if declared != release.version: + history_problems.append( + f"release {release.version}: its mkdocs.yml says {declared}" + ) + if unknown: + history_problems.append( + f"release {release.version}: pages neither mapped nor listed as " + f"other pages: {unknown}" + ) + history_problems.extend( + f"release {release.version}: {problem}" + for problem in found.resolver.problems + if in_shopping(problem.split(":", 1)[0]) + ) + stated_by_version[release.version] = [] + for document in found.documents.values(): + if not in_shopping(document["source_file"]): + continue + label = found.resolver.labels[document["source_file"]] + page_capabilities[document["source_file"]].update(label.capabilities) + for record in document["requirements"]: + annotate(record, label) + file = record["source"]["file"] + key = (file, record["text_digest"]) + if key in reviews: + used_reviews.add(key) + apply_review(record, reviews[key]) + stated_by_version[release.version].append( + Stated( + version=release.version, + wording=wording_of(record, identity.normalize), + position=(record["source"]["start_line"], record["document_order"]), + file=moved.get(file, file), + level=effective_level(record), + prefix=prefix_of(found.resolver.labels, file), + record=record, + ) + ) + + def related(page: str, other: str) -> bool: + """Return whether two pages share a capability.""" + return bool(page_capabilities[page] & page_capabilities[other]) + + history = trace_history( + versions, + stated_by_version, + { + entry["id"]: Wording( + entry["file"], entry["text_digest"], entry["context"], entry["text"] + ) + for entry in assigned.entries + if entry["status"] == "active" + }, + outside, + splits, + related, + ) + removed_ids, lock_entries, minted_removed = assign_removed_ids( + [history.stated[key] for key in history.removed], + assigned.entries, + args.spec_commit, + ) + keys = dict(zip(history.removed, removed_ids, strict=True)) + for record in records: + stated = history.stated.get(record["id"], []) + record["suite"]["since"] = stated[0].version if stated else DRAFT + record["suite"]["releases"] = statements(stated, record["text_digest"]) + removed_records = sorted( + ( + removed_record( + history.stated[key], keys[key], versions, config.published_page + ) + for key in history.removed + ), + key=lambda record: split_id(record["id"]), + ) + + # Checks. Anything here is unexpected and fails the run. + problems = list(resolver.problems) + review_problems + stale = sorted( + reviews[key]["id_at_review"] for key in set(reviews) - used_reviews + ) + if stale: + problems.append( + f"review: {len(stale)} decisions match no rule (reworded or " + f"removed): {stale[:5]}" + ) + unknown_actors = sorted( + {r["target_actor"] for r in records if r["suite"]["testable"] is None}, + key=str, + ) + if unknown_actors: + problems.append(f"actors this tool does not know: {unknown_actors}") + if extractor_dirty: + problems.append( + f"the extractor checkout has local changes ({extractor_commit})" + ) + unresolved = [r["id"] for r in records if not r["capabilities"]] + if unresolved: + problems.append( + f"{len(unresolved)} rules have no capability: {unresolved[:5]}" + ) + unknown = sorted({c for r in records for c in r["capabilities"]} - names) + if unknown: + problems.append(f"capabilities no schema declares: {unknown}") + duplicate_ids = [ + i for i, n in collections.Counter(r["id"] for r in records).items() if n > 1 + ] + if duplicate_ids: + problems.append(f"duplicate IDs: {duplicate_ids[:5]}") + problems.extend(lock_problems(lock, assigned)) + for path, document in documents.items(): + problems.extend( + f"{path}: {error}" for error in catalog.validate(without_suite(document)) + ) + index = capability_index(schemas, resolver.labels, records) + kinds = {entry["name"]: entry["kind"] for entry in index} + for rel_path, label in sorted(resolver.labels.items()): + in_extensions = PurePosixPath(rel_path).parent.name == "extensions" + for name in label.capabilities: + if in_extensions and kinds.get(name) != "extension": + problems.append( + f"{rel_path} is an extension page but {name} extends nothing" + ) + if not in_extensions and kinds.get(name) == "extension": + problems.append(f"{rel_path} is labelled with the extension {name}") + problems.extend(history_problems) + idle_splits = sorted(set(splits) - history.split) + if idle_splits: + problems.append( + f"review: splits that change nothing (the ID isn't stated in that " + f"version, or no older wording matches it): {idle_splits}" + ) + removed_actors = sorted( + { + r["target_actor"] + for r in removed_records + if r["suite"]["testable"] is None + }, + key=str, + ) + if removed_actors: + problems.append( + f"actors this tool does not know, in removed rules: {removed_actors}" + ) + removed_unresolved = [ + r["id"] for r in removed_records if not r["capabilities"] + ] + if removed_unresolved: + problems.append( + f"{len(removed_unresolved)} removed rules have no capability: " + f"{removed_unresolved[:5]}" + ) + retired_ids = {e["id"] for e in lock_entries if e["status"] == "retired"} + if len(set(removed_ids)) != len(removed_ids) or not retired_ids.issuperset( + removed_ids + ): + problems.append("lock: removed rules must have distinct, retired IDs") + problems.extend( + lock_problems( + assigned.entries, + LockResult( + ids=assigned.ids, + entries=lock_entries, + minted=minted_removed, + ), + ) + ) + + # Write, or with --check only compare. + report_document = {**report_document, "suite": suite_header} + index_document = { + "suite": suite_header, + "extends_from": "each extension schema's $defs keys that name another " + "capability", + "capabilities": index, + } + history_document = { + "about": HISTORY_ABOUT, + "suite": suite_header, + "versions": list(versions), + "releases": [ + { + "version": release.version, + "ref": release.ref, + "commit": release.commit, + "rules": len(stated_by_version[release.version]), + "matched": { + kind: history.matched[release.version][kind] for kind in MATCH_KINDS + }, + } + for release in releases.releases + ], + "removed": removed_records, + "moved_out": [ + { + "version": rule.version, + "file": rule.file, + "start_line": rule.position[0], + "clause": rule.record["clause"], + "now_on": pages, + } + for rule, pages in sorted( + history.moved_out, + key=lambda item: ( + versions.index(item[0].version), + item[0].file, + item[0].position, + ), + ) + ], + } + outputs = { + out_dir / path: catalog.serialize(document) + for path, document in documents.items() + } + outputs[out_dir / REPORT_FILE] = catalog.serialize(report_document) + outputs[out_dir / INDEX_FILE] = catalog.serialize(index_document) + outputs[out_dir / HISTORY_FILE] = catalog.serialize(history_document) + outputs[lock_path] = catalog.serialize(lock_document(lock_entries)) + pages_dir = out_dir / "shopping" + old_pages = set(pages_dir.rglob("*.json")) if pages_dir.exists() else set() + out_of_date = sorted( + (old_pages - set(outputs)) + | { + path + for path, text in outputs.items() + if not path.exists() or path.read_text(encoding="utf-8") != text + } + ) + if not args.check: + if pages_dir.exists(): + shutil.rmtree(pages_dir) + for path, text in outputs.items(): + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(text, encoding="utf-8") + + # Summary. + styles = collections.Counter(r["suite"]["keyword_style"] for r in records) + out(f"spec {args.spec_commit[:8]}, extractor {extractor_commit[:7]}\n") + out( + f"rules: {len(records)} ({styles['bold']} bold, " + f"{styles['capitals']} capitals); bold-only run: {len(bold_only)}\n" + ) + bold_digests = collections.Counter(r.text_digest for r in bold_only) + new_digests = collections.Counter(r["text_digest"] for r in records) + changed = bold_digests - new_digests + out( + "bold-only rules whose wording changed once capitals count: " + f"{sum(changed.values())}\n" + ) + bold_levels = { + (r.source.file, r.text_digest): str(r.level) for r in bold_only + } + level_changes = [ + (r["id"], bold_levels[key], r["level"]) + for r in records + if (key := (r["source"]["file"], r["text_digest"])) in bold_levels + and bold_levels[key] != r["level"] + ] + out(f"rules whose level changed once capitals count: {len(level_changes)}\n") + for change in level_changes[:10]: + out(f" {change[0]}: {change[1]} -> {change[2]}\n") + + out("\nby capability (bold / capitals):\n") + by_capability = collections.defaultdict(collections.Counter) + for record in records: + key = " + ".join(record["capabilities"]) + by_capability[key][record["suite"]["keyword_style"]] += 1 + for key in sorted(by_capability): + counts = by_capability[key] + out( + f" {sum(counts.values()):4} {key} " + f"({counts['bold']} / {counts['capitals']})\n" + ) + + out("\nby page:\n") + per_page = collections.Counter(r["source"]["file"] for r in records) + for rel_path in sorted(resolver.labels): + label = resolver.labels[rel_path] + short = PurePosixPath(rel_path).relative_to(SHOPPING_DIR) + caps = ", ".join( + c.removeprefix("dev.ucp.shopping.") for c in label.capabilities + ) + out( + f" {per_page[rel_path]:4} {short!s:28} " + f"{label.source:14} {caps or '-'}\n" + ) + + out("\ncapability index:\n") + for entry in index: + short_name = entry["name"].removeprefix("dev.ucp.shopping.") + if entry["kind"] == "extension": + relation = "extends " + ", ".join( + e.removeprefix("dev.ucp.shopping.") for e in entry["extends"] + ) + else: + relation = "extended by " + ( + ", ".join( + e.removeprefix("dev.ucp.shopping.") for e in entry["extended_by"] + ) + or "-" + ) + out( + f" {short_name:16} {entry['kind']:10} {relation:44} " + f"{len(entry['pages'])} pages, {entry['rules']} rules\n" + ) + in_scope = set(kinds) + elsewhere = sorted( + name + for name in names - in_scope + if set(parents_of(name, schemas)) & in_scope + ) + if elsewhere: + out( + " not in scope (outside the shopping folder) but extending a shopping " + "capability: " + ", ".join(elsewhere) + "\n" + ) + + out("\ntestable by this suite (REST, against a business):\n") + out(f" {'capability':16} {'rules':>5} {'testable':>8} {'MUST':>5}\n") + for entry in index: + out( + f" {entry['name'].removeprefix('dev.ucp.shopping.'):16} " + f"{entry['rules']:5} {entry['testable_rules']:8} " + f"{entry['testable_must']:5}\n" + ) + active = [r for r in records if is_active(r)] + testable_records = [r for r in active if r["suite"]["testable"]] + out( + f" {'unique rules':16} {len(active):5} {len(testable_records):8} " + f"{sum(effective_level(r) in MUST_LEVELS for r in testable_records):5}\n" + ) + for flag, title in ((True, "testable"), (False, "not testable")): + reasons = collections.Counter( + "reviewed" if "review" in r["suite"] else r["suite"]["testable_reason"] + for r in active + if r["suite"]["testable"] is flag + ) + out( + f" {title}: " + + ", ".join(f"{reason} {n}" for reason, n in reasons.most_common()) + + "\n" + ) + + reviewed = [r for r in records if "review" in r["suite"]] + if reviewed: + before = [t for t, _ in pre_review.values() if t] + before_must = sum( + bool(t) and level in MUST_LEVELS for t, level in pre_review.values() + ) + flips = collections.Counter( + (bool(pre_review[r["suite"]["positional_id"]][0]), r["suite"]["testable"]) + for r in reviewed + if is_active(r) + ) + actor_fixes = sum( + r["suite"]["review"]["actor"] != (r["target_actor"] or "none") + for r in reviewed + ) + calls = sum( + bool(r["suite"]["review"].get("needs_your_call")) for r in reviewed + ) + out( + f"\nreview ({args.review.name}): {len(reviewed)} decisions applied; " + f"{len(records) - len(active)} not a rule; {calls} need your call\n" + ) + out( + f" testable before review: {len(before)} ({before_must} MUST); " + f"after: {len(testable_records)} " + f"({sum(effective_level(r) in MUST_LEVELS for r in testable_records)}" + " MUST)\n" + ) + out( + f" testable -> not testable: {flips[(True, False)]}; " + f"not testable -> testable: {flips[(False, True)]}; " + f"actor set or corrected: {actor_fixes}\n" + ) + + statuses = collections.Counter(e["status"] for e in lock_entries) + out( + f"\nstable IDs ({LOCK_FILE}): kept {len(assigned.kept)}, carried over " + f"{len(assigned.carried)}, new {len(assigned.minted)}, retired " + f"{len(assigned.retired)}, restored {len(assigned.restored)}\n" + f" the lock holds {len(lock_entries)} IDs: {statuses['active']} " + f"active, {statuses['retired']} retired\n" + ) + if assigned.minted: + by_prefix = collections.Counter(split_id(i)[0] for i in assigned.minted) + out( + " new, by prefix: " + + ", ".join(f"{p} {n}" for p, n in sorted(by_prefix.items())) + + "\n" + ) + where = { + e["id"]: e["file"].removeprefix(f"{SHOPPING_DIR}/") + for e in assigned.entries + } + for record in records: + where[record["id"]] += f":{record['source']['start_line']}" + for title, listed in ( + ("new", assigned.minted), + ("retired", assigned.retired), + ("restored", assigned.restored), + ): + if len(listed) <= LIST_LIMIT: + for rule_id in listed: + out(f" {title}: {rule_id} at {where[rule_id]}\n") + wording = {e["id"]: e["text"] for e in assigned.entries} + for rule_id, alike, before in assigned.carried: + out( + f" carried over: {rule_id} at {where[rule_id]}, {alike:.0%} " + "alike; check it is the same rule\n" + f" was: {before[:100]}\n now: {wording[rule_id][:100]}\n" + ) + + def must_in(record: dict[str, Any]) -> list[str]: + """Return the versions in which a testable rule is a MUST.""" + if not is_active(record) or not record["suite"]["testable"]: + return [] + stated = [(s["version"], s["level"]) for s in record["suite"]["releases"]] + if record["suite"].get("until") is None: + stated.append((DRAFT, effective_level(record))) + return [version for version, level in stated if level in MUST_LEVELS] + + out( + f"\nrelease history ({args.releases.name}, {HISTORY_FILE}): " + f"{len(releases.releases)} releases\n" + ) + for release in releases.releases: + counts = history.matched[release.version] + out( + f" {release.version} ({release.commit[:8]}): " + f"{len(stated_by_version[release.version])} shopping rules; " + + ", ".join( + f"{kind} {counts[kind]}" for kind in MATCH_KINDS if counts[kind] + ) + + "\n" + ) + first = collections.Counter( + r["suite"]["since"] for r in records if is_active(r) + ) + first_must = collections.Counter( + r["suite"]["since"] for r in records if DRAFT in must_in(r) + ) + stated_must = collections.Counter( + version for r in (*records, *removed_records) for version in must_in(r) + ) + for title, counts in ( + ("rules by first version", first), + ("testable MUST rules by first version", first_must), + ("testable MUST rules each version states", stated_must), + ): + out( + f" {title}: " + + ", ".join(f"{v} {counts[v]}" for v in versions if counts[v]) + + "\n" + ) + removed_must = [r for r in removed_records if must_in(r)] + out( + f" removed rules: {len(removed_records)}, {len(removed_must)} of them " + f"testable MUST; new IDs {len(minted_removed)}\n" + ) + for record in removed_must: + if "review" not in record["suite"]: + out( + f" not reviewed: {record['id']} ({record['suite']['since']} to " + f"{record['suite']['releases'][-1]['version']}, " + f"{record['suite']['testable_reason']}): {record['clause'][:90]}\n" + ) + if history.moved_out: + out(f" moved out of the shopping pages: {len(history.moved_out)}\n") + for rule, key, newer, alike in history.reworded: + out( + f" reworded: {keys.get(key, key)} in {rule.version} at " + f"{rule.file.removeprefix(f'{DOCS_ROOT}/')}:{rule.position[0]}, " + f"{alike:.0%} alike; check it is the same rule\n" + f" was: {rule.wording.text[:100]}\n now: {newer.text[:100]}\n" + ) + + out( + f"\n{'would write' if args.check else 'wrote'} {len(documents)} page " + f"files, {REPORT_FILE}, {INDEX_FILE}, {HISTORY_FILE} and {LOCK_FILE} to " + f"{out_dir}; {len(out_of_date)} files " + f"{'differ' if args.check else 'changed'}\n" + ) + if args.check and out_of_date: + out("check: nothing was written; out of date:\n") + for path in out_of_date[:LIST_LIMIT]: + out(f" - {path.relative_to(out_dir)}\n") + if len(out_of_date) > LIST_LIMIT: + out(f" - and {len(out_of_date) - LIST_LIMIT} more\n") + elif args.check: + out("check: every output is up to date\n") + if problems: + out("\nPROBLEMS:\n" + "".join(f" - {p}\n" for p in problems)) + return 1 + if args.check and out_of_date: + return 1 + out( + "checks: every rule has a capability and its own stable ID, all names " + "are declared, no conflicts, every extension page belongs to an " + "extension, every page fits the catalog schema, every release was read " + "and every removed rule has a retired ID\n" + ) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/runner.py b/runner.py index ec0ce2e..56a10f6 100644 --- a/runner.py +++ b/runner.py @@ -24,6 +24,7 @@ import sys import unittest from absl import flags +from framework import marker_check from framework.base_test import BaseIntegrationTest, is_local_url from framework.discovery import ( UcpProfile, @@ -409,6 +410,16 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace: action="store_true", help="List selected test cases without contacting the server.", ) + parser.add_argument( + "--requirements_check", + "--requirements-check", + dest="requirements_check", + choices=marker_check.MODES, + default="strict", + help="Check the shopping tests' spec markers against the requirements " + "catalog before running: strict stops on problems, warn only reports " + "them, off skips the check (default: strict).", + ) args = parser.parse_args(argv) target = {} if args.target_dir: @@ -482,6 +493,20 @@ def main(argv: list[str] | None = None) -> int: f"Resolved {total_tests} test cases across suite '{args.suite}'\n" ) + loaded = [ + marker_check.from_unittest(test) for test in _iter_tests(test_suite) + ] + report, stop = marker_check.evaluate(loaded, args.requirements_check) + if report: + sys.stdout.write("\n" + report) + if stop: + sys.stdout.flush() + sys.stderr.write( + "\nRequirements check failed: fix the problems above, or pass " + "--requirements_check=warn to run anyway.\n" + ) + return 1 + if args.dry_run: sys.stdout.write("\nDry Run - Selected Tests:\n") for test in _iter_tests(test_suite): diff --git a/shopping/checkout/business_logic_test.py b/shopping/checkout/business_logic_test.py index 67a0d2f..7f8e6fb 100644 --- a/shopping/checkout/business_logic_test.py +++ b/shopping/checkout/business_logic_test.py @@ -15,7 +15,13 @@ """Business logic and totals tests for the UCP Shopping vertical.""" from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import ( + no_rule, + older_version, + partly, + requires_capability, + spec_assert, +) from shopping.base import ShoppingIntegrationTestBase from ucp_sdk.models.schemas.shopping import checkout as checkout from ucp_sdk.models.schemas.shopping import ( @@ -53,6 +59,14 @@ class BusinessLogicTest(ShoppingIntegrationTestBase): - GET /checkout-sessions/{id} """ + @spec_assert( + partly( + "REQ-SHOPPING-CHECKOUT-0016", # line total MUST be price x quantity + "a quantity of 1 with integer prices only, so scale and rounding " + "aren't checked", + ), + "REQ-SHOPPING-CHECKOUT-0134", # Exactly one "total" MUST be present + ) def test_totals_calculation_on_create(self): """Test that totals are calculated correctly upon checkout creation. @@ -92,6 +106,9 @@ def test_totals_calculation_on_create(self): # Verify Totals Breakdown self.assert_totals_consistent(checkout_obj, expected_price) + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0134", # Exactly one "total" MUST be present + ) def test_totals_recalculation_on_update(self): """Test that totals are recalculated correctly upon checkout update. @@ -139,6 +156,12 @@ def test_totals_recalculation_on_update(self): expected_total = expected_price * 2 self.assert_totals_consistent(updated_checkout, expected_total) + @older_version( + "2026-04-08", + "sends boolean consent flags (marketing, analytics); the draft keys " + "purposes by reverse-DNS ID and businesses MUST ignore unadvertised " + "ones (REQ-SHOPPING-BUYER-CONSENT-0010)", + ) @requires_capability("dev.ucp.shopping.buyer_consent") def test_buyer_consent(self): """Test that buyer consent preferences are persisted on creation. @@ -212,6 +235,11 @@ def test_buyer_consent(self): f"Analytics consent not persisted. Resp: {consent_data}", ) + @no_rule( + "checkout/index.md, Update Checkout: the request 'will replace the " + "existing checkout session state on the business side', with no " + "keyword" + ) def test_buyer_info_persistence(self): """Test that buyer information is persisted on update. diff --git a/shopping/checkout/field_ownership_test.py b/shopping/checkout/field_ownership_test.py index 8ba471c..46818fd 100644 --- a/shopping/checkout/field_ownership_test.py +++ b/shopping/checkout/field_ownership_test.py @@ -32,7 +32,7 @@ """ from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import no_rule, outside_catalog, requires_capability from shopping.base import ShoppingIntegrationTestBase from ucp_sdk.models.schemas.shopping import checkout as checkout from ucp_sdk.models.schemas.shopping.payment import Payment @@ -115,6 +115,11 @@ def _assert_caller_values_absent(self, data: dict, where: str) -> None: f"the caller-supplied value must not appear in {where}", ) + @outside_catalog( + "checkout.json marks continue_url, expires_at, messages and order with " + "ucp_request: omit, so no request variant carries them; the schemas are " + "outside the catalog's pages" + ) def test_create_does_not_adopt_caller_supplied_omit_members(self) -> None: """The create response must not echo back caller-owned-field values. @@ -127,6 +132,11 @@ def test_create_does_not_adopt_caller_supplied_omit_members(self) -> None: data = self._post_checkout_with_caller_supplied_fields() self._assert_caller_values_absent(data, "the create response") + @outside_catalog( + "checkout.json marks continue_url, expires_at, messages and order with " + "ucp_request: omit, so no request variant carries them; the schemas are " + "outside the catalog's pages" + ) def test_create_does_not_persist_caller_supplied_omit_members(self) -> None: """Caller-owned-field values must not be persisted, only reflected. @@ -148,6 +158,10 @@ def test_create_does_not_persist_caller_supplied_omit_members(self) -> None: stored = response.json() self._assert_caller_values_absent(stored, "the stored checkout") + @no_rule( + "control case for the two omit-member tests: a create that never sends " + "the server-owned members is the ordinary create flow" + ) def test_create_without_omit_members_is_unaffected(self) -> None: """A create that never sends these members must still succeed. diff --git a/shopping/checkout/idempotency_test.py b/shopping/checkout/idempotency_test.py index 577f9c2..ed52e41 100644 --- a/shopping/checkout/idempotency_test.py +++ b/shopping/checkout/idempotency_test.py @@ -16,7 +16,10 @@ import uuid from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import ( + outside_catalog, + requires_capability, +) from shopping.base import get_valid_payment_payload, ShoppingIntegrationTestBase from ucp_sdk.models.schemas.shopping import checkout as checkout @@ -44,6 +47,13 @@ class IdempotencyTest(ShoppingIntegrationTestBase): - POST /checkout-sessions/{id}/cancel """ + @outside_catalog( + "checkout/rest.md, Specific Header Requirements (rendered by the " + "header_requirements macro, so the catalog lacks it): when an " + "Idempotency-Key is provided the server MUST return the cached result " + "for a duplicate key with a matching body and 409 Conflict for a " + "mismatched body" + ) def test_idempotency_create(self) -> None: """Test that checkout creation is idempotent. @@ -97,6 +107,13 @@ def test_idempotency_create(self) -> None: ) self.assert_response_status(response3, 409) + @outside_catalog( + "checkout/rest.md, Specific Header Requirements (rendered by the " + "header_requirements macro, so the catalog lacks it): when an " + "Idempotency-Key is provided the server MUST return the cached result " + "for a duplicate key with a matching body and 409 Conflict for a " + "mismatched body" + ) def test_idempotency_update(self) -> None: """Test that checkout update is idempotent. @@ -174,6 +191,13 @@ def test_idempotency_update(self) -> None: ) self.assert_response_status(response3, 409) + @outside_catalog( + "checkout/rest.md, Specific Header Requirements (rendered by the " + "header_requirements macro, so the catalog lacks it): when an " + "Idempotency-Key is provided the server MUST return the cached result " + "for a duplicate key with a matching body and 409 Conflict for a " + "mismatched body" + ) def test_idempotency_complete(self) -> None: """Test that checkout completion is idempotent. @@ -227,6 +251,12 @@ def test_idempotency_complete(self) -> None: ) self.assert_response_status(response3, 409) + @outside_catalog( + "checkout/rest.md, Specific Header Requirements (rendered by the " + "header_requirements macro, so the catalog lacks it): when an " + "Idempotency-Key is provided the server MUST return the cached result " + "for a duplicate key with a matching body" + ) def test_idempotency_cancel(self) -> None: """Test that checkout cancellation is idempotent. diff --git a/shopping/checkout/lifecycle_test.py b/shopping/checkout/lifecycle_test.py index 9070b96..834306d 100644 --- a/shopping/checkout/lifecycle_test.py +++ b/shopping/checkout/lifecycle_test.py @@ -15,7 +15,12 @@ """Checkout Lifecycle tests for the UCP SDK Server.""" from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import ( + no_rule, + partly, + requires_capability, + spec_assert, +) from shopping.base import ShoppingIntegrationTestBase, get_valid_payment_payload from ucp_sdk.models.schemas.shopping import ( checkout_update_request as checkout_update_req, @@ -67,6 +72,11 @@ class CheckoutLifecycleTest(ShoppingIntegrationTestBase): "name": "Conformance Test Buyer", } + @no_rule( + "checkout/index.md, Operations: Create Checkout 'Initiates a new " + "checkout session'; the response's id is schema-required, with no " + "keyword" + ) def test_create_checkout(self): """Test successful checkout creation. @@ -78,6 +88,10 @@ def test_create_checkout(self): created_checkout = checkout.Checkout(**response_json) self.assertTrue(created_checkout.id, "Created checkout missing ID") + @no_rule( + "checkout/index.md, Get Checkout: 'It provides the latest state of " + "the checkout resource', with no keyword" + ) def test_get_checkout(self): """Test successful checkout retrieval. @@ -101,6 +115,11 @@ def test_get_checkout(self): msg="Get checkout returned wrong ID", ) + @no_rule( + "checkout/index.md, Update Checkout: the request 'will replace the " + "existing checkout session state on the business side', with no " + "keyword" + ) def test_update_checkout(self): """Test successful checkout update. @@ -220,6 +239,9 @@ def test_update_checkout(self): self.assertEqual(selected_dest.get("postal_code"), "90210") self.assertEqual(selected_dest.get("street_address"), "456 Elm St") + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0120", # non-terminal checkouts SHOULD be cancelable + ) def test_cancel_checkout(self): """Test successful checkout cancellation. @@ -244,6 +266,10 @@ def test_cancel_checkout(self): msg=f"Checkout status not 'canceled', got '{canceled_checkout.status}'", ) + @no_rule( + "checkout/index.md, Complete Checkout: on completion, status is " + "completed and order carries id and permalink_url, with no keyword" + ) def test_complete_checkout(self): """Test successful checkout completion. @@ -284,6 +310,11 @@ def test_complete_checkout(self): "order.permalink_url missing", ) + @no_rule( + "checkout/index.md, Status Values: 'ready_for_complete' means the session " + "'has all necessary information' and 'No Action remains outstanding', " + "with no keyword" + ) def test_ready_for_complete_when_nothing_is_outstanding(self): """Test that a checkout with nothing outstanding reports readiness. @@ -355,6 +386,11 @@ def _cancel_checkout(self, checkout_id): self.assert_response_status(response, 200) return response + @no_rule( + "accepts the error REQ-SHOPPING-CHECKOUT-0119 recommends or an " + "idempotent 200, so it cannot fail on that rule; it only rules out " + "server errors" + ) def test_repeated_cancel(self): """Test repeated cancellation behavior. @@ -401,6 +437,10 @@ def test_repeated_cancel(self): msg="Repeated cancellation must not produce a server error.", ) + @no_rule( + "checkout/index.md, Status Values: a canceled session 'is invalid " + "or expired'; no keyword says updates to it must be refused" + ) def test_cannot_update_canceled_checkout(self): """Test that a canceled checkout cannot be updated. @@ -455,6 +495,11 @@ def test_cannot_update_canceled_checkout(self): msg="Updating a canceled checkout must not produce a server error.", ) + @no_rule( + "checkout/index.md: Complete Checkout places the order 'from " + "ready_for_complete'; no keyword says completing a canceled " + "session must fail" + ) def test_cannot_complete_canceled_checkout(self): """Test that a canceled checkout cannot be completed. @@ -494,6 +539,10 @@ def _complete_checkout(self, checkout_id): self.assert_response_status(response, 200) return response + @no_rule( + "checkout/index.md, Business guidelines: a completed session 'is " + "considered immutable', with no keyword" + ) def test_complete_is_idempotent(self): """Tests that completing an already completed checkout behaves correctly. @@ -524,6 +573,10 @@ def test_complete_is_idempotent(self): msg="Completing a completed checkout must not be a server error.", ) + @no_rule( + "checkout/index.md, Business guidelines: a completed session 'is " + "considered immutable', with no keyword" + ) def test_cannot_update_completed_checkout(self): """Test that a completed checkout cannot be updated. @@ -578,6 +631,13 @@ def test_cannot_update_completed_checkout(self): msg="Updating a completed checkout must not produce a server error.", ) + @spec_assert( + partly( + "REQ-SHOPPING-CHECKOUT-0119", # cancel after completion SHOULD fail + "only a 4xx status, so an in-band error fails and the error's content " + "isn't checked", + ), + ) def test_cannot_cancel_completed_checkout(self): """Test that a completed checkout cannot be canceled. diff --git a/shopping/checkout/protocol_test.py b/shopping/checkout/protocol_test.py index e20160b..575d92c 100644 --- a/shopping/checkout/protocol_test.py +++ b/shopping/checkout/protocol_test.py @@ -21,7 +21,10 @@ from absl.testing import absltest from framework.base_test import DEFAULT_UCP_VERSION -from framework.decorators import requires_capability +from framework.decorators import ( + outside_catalog, + requires_capability, +) from shopping.base import ShoppingIntegrationTestBase, rest_entry from ucp_sdk.models.schemas.shopping import checkout as checkout @@ -71,6 +74,10 @@ def _shopping_service(self, ucp_data: dict) -> dict: ) return rest_entry(entries) or entries[0] + @outside_catalog( + "overview/index.md: the advertised shopping service, with its " + "version, REST transport and endpoint (core discovery rules)" + ) def test_shopping_service_advertisement(self): """Test that the shopping service is advertised correctly. @@ -108,6 +115,10 @@ def test_shopping_service_advertisement(self): ) self.assertIsNotNone(shopping_service.get("endpoint")) + @outside_catalog( + "overview/index.md, Request-Time Validation: a request with an " + "unsupported version MUST get a version_unsupported error" + ) def test_version_negotiation(self): """Test protocol version negotiation via headers. diff --git a/shopping/checkout/totals_test.py b/shopping/checkout/totals_test.py index 41ef4dd..4e9c372 100644 --- a/shopping/checkout/totals_test.py +++ b/shopping/checkout/totals_test.py @@ -32,7 +32,11 @@ """ from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import ( + no_rule, + requires_capability, + spec_assert, +) from shopping.base import ShoppingIntegrationTestBase from ucp_sdk.models.schemas.shopping import checkout as checkout @@ -97,6 +101,9 @@ def _discounted_checkout_totals(self) -> list[dict]: ) return totals + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0133", # Exactly one "subtotal" MUST be present + ) def test_single_subtotal_entry(self): """Test that totals contain exactly one subtotal entry. @@ -112,6 +119,9 @@ def test_single_subtotal_entry(self): f"totals[] must contain exactly one 'subtotal' entry, found {totals}.", ) + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0134", # Exactly one "total" MUST be present + ) def test_single_total_entry(self): """Test that totals contain exactly one total entry. @@ -127,6 +137,10 @@ def test_single_total_entry(self): f"totals[] must contain exactly one 'total' entry, found {totals}.", ) + @no_rule( + "checkout/index.md, totals[] invariants: 'Every entry carries a type and " + "an amount' and 'Amounts are signed integers', with no keyword" + ) def test_entries_have_type_and_amount(self): """Test that every totals entry carries a type and an amount. @@ -156,6 +170,9 @@ def test_entries_have_type_and_amount(self): f"totals 'amount' must be an integer, not a boolean: {entry}.", ) + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0143", # additive types MUST be non-negative + ) def test_additive_entries_non_negative(self): """Test that additive charge entries have a non-negative amount. @@ -177,6 +194,9 @@ def test_additive_entries_non_negative(self): f"Additive '{entry.get('type')}' entry must be >= 0: {entry}.", ) + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0142", # subtractive types MUST be negative + ) @requires_capability("dev.ucp.shopping.discount") def test_discount_entry_is_negative(self): """Test that a discount totals entry has a negative amount. diff --git a/shopping/discount/discount_test.py b/shopping/discount/discount_test.py index 2635e0f..5ceea24 100644 --- a/shopping/discount/discount_test.py +++ b/shopping/discount/discount_test.py @@ -15,7 +15,10 @@ """Discount application tests for the UCP Shopping vertical.""" from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import ( + no_rule, + requires_capability, +) from shopping.base import ShoppingIntegrationTestBase from ucp_sdk.models.schemas.shopping import checkout as checkout from ucp_sdk.models.schemas.shopping import discount as discount @@ -51,6 +54,10 @@ class DiscountTest(ShoppingIntegrationTestBase): - PUT /checkout-sessions/{id} """ + @no_rule( + "discount.md, Operations: active discounts appear in discounts.applied " + "and their amounts in totals[], with no keyword" + ) def test_discount_flow(self): """Test that valid discount codes decrease the total amount. @@ -123,6 +130,10 @@ def test_discount_flow(self): "Applied discounts field incorrect", ) + @no_rule( + "discount.md: one or more codes can be submitted and stack by priority; " + "both then appear in discounts.applied, with no keyword" + ) def test_multiple_discounts_accepted(self): """Test that multiple valid discount codes are both applied. @@ -182,6 +193,10 @@ def test_multiple_discounts_accepted(self): self.assertIn(valid_code_1, applied_codes) self.assertIn(valid_code_2, applied_codes) + @no_rule( + "discount.md, Rejected Codes: a code that cannot be applied is reported " + "in messages[], and applied lists only active discounts; no keyword" + ) def test_multiple_discounts_one_rejected(self): """Test requesting multiple discounts where one is valid and one is not. @@ -221,6 +236,10 @@ def test_multiple_discounts_one_rejected(self): self.assertIn(valid_code, applied_codes) self.assertNotIn("INVALID_CODE", applied_codes) + @no_rule( + "discount.md, Allocation Details: applied[].amount is the discount's " + "magnitude and totals[] its signed effect, with no keyword" + ) def test_fixed_amount_discount(self): """Test that a fixed-amount discount code decreases the total correctly. @@ -268,6 +287,10 @@ def test_fixed_amount_discount(self): "applied discount amount must match the configured fixed reduction", ) + @no_rule( + "discount.md, Rejected Codes: a code that cannot be applied is reported " + "in messages[]; no keyword says it must not produce a discount" + ) def test_unknown_discount_code(self): """Test that unknown discount codes are ignored.""" response_json = self.create_checkout_session() diff --git a/shopping/discount/semantics_test.py b/shopping/discount/semantics_test.py index 88e7c5d..ead35a4 100644 --- a/shopping/discount/semantics_test.py +++ b/shopping/discount/semantics_test.py @@ -34,7 +34,12 @@ """ from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import ( + no_rule, + partly, + requires_capability, + spec_assert, +) from shopping.base import ShoppingIntegrationTestBase from ucp_sdk.models.schemas.shopping import checkout as checkout @@ -85,6 +90,10 @@ def _applied_codes(raw): ] # ── DSC-005: case-insensitive matching (discount.md) ──────────────────── + @no_rule( + "discount.md, Operations: 'Codes are matched case-insensitively by " + "business', with no keyword" + ) def test_code_matches_case_insensitively(self): """A code submitted in a different case still matches and applies.""" base, _ = self._new_checkout() @@ -106,6 +115,12 @@ def test_code_matches_case_insensitively(self): ) # ── discount total is negative (discount.md / total.json) ─────────────── + @spec_assert( + partly( + "REQ-SHOPPING-CHECKOUT-0142", # subtractive types MUST be negative + "the discount entry only, not items_discount", + ), + ) def test_discount_total_is_negative(self): """A discount's totals[] entry is negative (total.json exclusiveMax 0).""" base, base_raw = self._new_checkout() @@ -126,6 +141,10 @@ def test_discount_total_is_negative(self): ) # ── DSC-022: allocations sum to the applied discount amount ───────────── + @no_rule( + "discount.md, Allocations Array: an 'Invariant' that allocations sum to " + "applied_discount.amount, with no keyword" + ) def test_allocations_sum_to_applied_amount(self): """Each applied discount's allocations sum to its amount (discount.md). @@ -155,6 +174,11 @@ def test_allocations_sum_to_applied_amount(self): self.skipTest("server does not emit discount allocations[]") # ── DSC-027: client-supplied applied[] must not change pricing ────────── + @no_rule( + "discount.md, Operations: codes fall under 'Request behavior' and " + "applied under 'Response behavior'; no keyword says a submitted applied[] " + "is ignored" + ) def test_client_applied_does_not_change_price(self): """Injected discounts.applied[] must not lower the priced total. @@ -193,6 +217,10 @@ def test_client_applied_does_not_change_price(self): ) # ── DSC-004: empty codes[] removes all discounts ──────────────────────── + @no_rule( + "discount.md, Operations: an empty codes array removes all discount " + "codes, with no keyword" + ) def test_empty_codes_removes_discount(self): """Sending codes:[] removes previously applied discounts.""" base, _ = self._new_checkout() @@ -210,6 +238,10 @@ def test_empty_codes_removes_discount(self): ) # ── DSC-003: a new codes[] set replaces the previous one ──────────────── + @no_rule( + "discount.md, Operations: 'Submitting discounts.codes replaces any " + "previously submitted codes', with no keyword" + ) def test_codes_replace_previous_set(self): """Submitting discounts.codes replaces any previously submitted codes.""" second = self.fixture_ctx.get_test_discount_code_2() diff --git a/shopping/fulfillment/fulfillment_test.py b/shopping/fulfillment/fulfillment_test.py index 2939adf..7436756 100644 --- a/shopping/fulfillment/fulfillment_test.py +++ b/shopping/fulfillment/fulfillment_test.py @@ -17,7 +17,13 @@ import uuid from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import ( + no_rule, + older_version, + requires_capability, + scenario, + spec_assert, +) from shopping.base import CustomerFixture from shopping.base import shopping_test_data from shopping.base import ShoppingIntegrationTestBase @@ -86,6 +92,10 @@ def _get_free_shipping_option(self, options: list[dict]) -> dict | None: return option return None + @no_rule( + "fulfillment.md, Overview: Checkout fulfillment covers 'selection and " + "cost'; no keyword says the total includes the selected option's cost" + ) def test_fulfillment_flow(self) -> None: """Test the complete fulfillment selection flow. @@ -202,6 +212,10 @@ def test_fulfillment_flow(self) -> None: ), ) + @scenario( + "the domestic and international destinations offer the option IDs set " + "in the fixtures, which are the store's own data" + ) def test_dynamic_fulfillment(self) -> None: """Test that fulfillment options are dynamically generated based on address. @@ -289,6 +303,10 @@ def test_dynamic_fulfillment(self) -> None: f"{international['expected_option_id']}, got {options}", ) + @scenario( + "an unknown buyer gets no saved addresses filled in; filling in saved " + "addresses by buyer email is a store feature no rule covers" + ) def test_unknown_customer_no_address(self) -> None: """Test that an unknown customer gets no automatic address injection.""" # Create checkout with a randomized buyer email so it cannot collide @@ -322,6 +340,10 @@ def test_unknown_customer_no_address(self) -> None: destinations = method.get("destinations") self.assertTrue(destinations is None or len(destinations) == 0) + @scenario( + "a known buyer with no saved addresses gets none filled in; filling in " + "saved addresses is a store feature no rule covers" + ) def test_known_customer_no_address(self) -> None: """Test that a known customer with no stored address gets no injection.""" customer = self.fixture_ctx.get_known_customer_without_address() @@ -353,6 +375,10 @@ def test_known_customer_no_address(self) -> None: destinations = method.get("destinations") self.assertTrue(destinations is None or len(destinations) == 0) + @scenario( + "a known buyer's saved addresses are filled in as destinations; filling " + "in saved addresses is a store feature no rule covers" + ) def test_known_customer_one_address(self) -> None: """Test that a known customer's stored addresses get injected.""" customer = self.fixture_ctx.get_known_customer() @@ -392,6 +418,11 @@ def test_known_customer_one_address(self) -> None: f"Stored address {address} not found in destinations {destinations}", ) + @spec_assert( + "REQ-SHOPPING-FULFILLMENT-0012", # same selected_destination_id returned + "REQ-SHOPPING-FULFILLMENT-0013", # one matching typed destination entry + "REQ-SHOPPING-FULFILLMENT-0015", # no silent substitution of destination + ) def test_known_customer_multiple_addresses_selection(self) -> None: """Test selecting between multiple addresses for a known customer.""" customer = self.fixture_ctx.get_known_customer() @@ -474,6 +505,11 @@ def test_known_customer_multiple_addresses_selection(self) -> None: f"Selected destination {selected_dest} does not match {target_address}", ) + @older_version( + "2026-04-08", + "accepts a server-substituted selected_destination_id; the draft " + "forbids returning a different one (REQ-SHOPPING-FULFILLMENT-0015)", + ) def test_known_customer_new_address(self) -> None: """Test that providing a new address works for a known customer.""" customer = self.fixture_ctx.get_known_customer() @@ -552,6 +588,10 @@ def test_known_customer_new_address(self) -> None: f"No fulfillment options generated for new destination: {group}", ) + @scenario( + "resubmitted saved-address content comes back under its existing ID, " + "a store feature (address de-duplication) that no rule covers" + ) def test_known_user_existing_address_reuse(self) -> None: """Test that an existing address is reused (same ID returned). @@ -632,6 +672,9 @@ def test_known_user_existing_address_reuse(self) -> None: "Resubmitted stored address was not reused under its existing id", ) + @scenario( + "a zero-cost option above the store's free-shipping threshold (fixtures)" + ) def test_free_shipping_on_expensive_order(self) -> None: """Test that free shipping is offered above the configured threshold.""" threshold = self.fixture_ctx.get_free_shipping_min_subtotal() @@ -683,6 +726,7 @@ def test_free_shipping_on_expensive_order(self) -> None: f" free-shipping threshold. Options: {options}", ) + @scenario("a zero-cost option for the store's free-shipping item (fixtures)") def test_free_shipping_for_specific_item(self) -> None: """Test that free shipping is offered for eligible items.""" eligible_sku = self.fixture_ctx.get_free_shipping_item_sku() diff --git a/shopping/fulfillment/structure_test.py b/shopping/fulfillment/structure_test.py index 7fcbb36..2de52b0 100644 --- a/shopping/fulfillment/structure_test.py +++ b/shopping/fulfillment/structure_test.py @@ -43,7 +43,10 @@ """ from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import ( + requires_capability, + spec_assert, +) from shopping.base import ShoppingIntegrationTestBase from ucp_sdk.models.schemas.shopping import checkout as checkout from ucp_sdk.models.schemas.shopping import checkout_create_request @@ -112,6 +115,9 @@ def _checkout_with_options(self) -> dict: checkout_obj, fulfillment=fulfillment_payload ) + @spec_assert( + "REQ-SHOPPING-FULFILLMENT-0018", # option title MUST distinguish siblings + ) def test_option_titles_distinguish_siblings(self) -> None: """FUL-001: sibling ``options[].title`` are non-empty and distinct. @@ -155,6 +161,9 @@ def test_option_titles_distinguish_siblings(self) -> None: if groups_with_options == 0: self.skipTest("server generated no fulfillment options to assert on") + @spec_assert( + "REQ-SHOPPING-FULFILLMENT-0048", # single group per method by default + ) def test_default_config_single_group_per_method(self) -> None: """FUL-008: under default config a method has one consolidating group. diff --git a/shopping/order/order_test.py b/shopping/order/order_test.py index 33c9e8f..e480a4a 100644 --- a/shopping/order/order_test.py +++ b/shopping/order/order_test.py @@ -18,7 +18,11 @@ import uuid from absl import flags from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import ( + requires_capability, + scenario, + spec_assert, +) from pydantic import AnyUrl from shopping.base import get_valid_payment_payload from shopping.base import shopping_test_data @@ -57,6 +61,9 @@ class OrderTest(ShoppingIntegrationTestBase): - PUT /orders/{id} """ + @spec_assert( + "REQ-SHOPPING-ORDER-0008", # full order entity on every response + ) def test_order_retrieval(self) -> None: """Test successful order retrieval. @@ -82,6 +89,10 @@ def test_order_retrieval(self) -> None: order_data.checkout_id, checkout_id, "Checkout ID mismatch" ) + @scenario( + "the order's first expectation reuses the selected option's title as " + "its description, a sample server choice that no rule requires" + ) def test_order_fulfillment_retrieval(self) -> None: """Test that fulfillment expectations are persisted in the order. @@ -200,6 +211,10 @@ def test_order_fulfillment_retrieval(self) -> None: "Expectation description mismatch", ) + @scenario( + "adds a shipped event through PUT /orders/{id}, the sample server's own " + "endpoint; the spec defines only GET /orders/{id}" + ) def test_order_update(self) -> None: """Test updating an existing order. @@ -334,6 +349,10 @@ def test_order_update(self) -> None: msg="Order event not persisted", ) + @scenario( + "adds a refund adjustment through PUT /orders/{id}, the sample server's " + "own endpoint; the spec defines only GET /orders/{id}" + ) def test_order_adjustments(self) -> None: """Test that order adjustments are persisted. diff --git a/shopping/order/simulation_url_security_test.py b/shopping/order/simulation_url_security_test.py index 10dc003..bf2d927 100644 --- a/shopping/order/simulation_url_security_test.py +++ b/shopping/order/simulation_url_security_test.py @@ -21,7 +21,10 @@ from absl.testing import absltest from framework.base_test import FLAGS -from framework.decorators import requires_capability +from framework.decorators import ( + requires_capability, + scenario, +) from shopping.base import ShoppingIntegrationTestBase @@ -29,6 +32,11 @@ class SecurityTest(ShoppingIntegrationTestBase): """Tests for security controls.""" + @scenario( + "the store's /testing/simulate-shipping hook and its Simulation-Secret, " + "a test harness of the implementation under test that no specification " + "page describes" + ) def test_simulation_endpoint_missing_header(self): """Test access without the secret header returns 403.""" order_id = self.create_completed_order() @@ -38,6 +46,11 @@ def test_simulation_endpoint_missing_header(self): ) self.assert_response_status(response, 403) + @scenario( + "the store's /testing/simulate-shipping hook and its Simulation-Secret, " + "a test harness of the implementation under test that no specification " + "page describes" + ) def test_simulation_endpoint_incorrect_secret(self): """Test access with an incorrect secret returns 403.""" order_id = self.create_completed_order() @@ -49,6 +62,11 @@ def test_simulation_endpoint_incorrect_secret(self): ) self.assert_response_status(response, 403) + @scenario( + "the store's /testing/simulate-shipping hook and its Simulation-Secret, " + "a test harness of the implementation under test that no specification " + "page describes" + ) def test_simulation_endpoint_correct_secret(self): """Test access with the correct secret returns 200.""" order_id = self.create_completed_order() diff --git a/shopping/order/webhook_structure_test.py b/shopping/order/webhook_structure_test.py index 35513e8..b11e241 100644 --- a/shopping/order/webhook_structure_test.py +++ b/shopping/order/webhook_structure_test.py @@ -50,7 +50,13 @@ from absl.testing import absltest from framework.base_test import FLAGS -from framework.decorators import requires_capability +from framework.decorators import ( + no_rule, + older_version, + partly, + requires_capability, + spec_assert, +) from framework.mock_webhook_server import MockWebhookServer from shopping.base import ShoppingIntegrationTestBase @@ -174,6 +180,10 @@ def _assert_full_order_entity( ) # ── order.md "Order Event Webhook": Standard Webhooks headers ─────────── + @no_rule( + "order/index.md, Order Event Webhook: a 'Required Headers' table lists " + "Webhook-Id and Webhook-Timestamp (unix), with no keyword" + ) def test_delivery_carries_standard_webhook_headers(self) -> None: """Every delivery carries Webhook-Id and a unix Webhook-Timestamp.""" _, _, event = self._place_order() @@ -196,6 +206,11 @@ def test_delivery_carries_standard_webhook_headers(self) -> None: f"Webhook-Timestamp {timestamp} does not parse as unix seconds", ) + @spec_assert( + "REQ-SHOPPING-ORDER-0018", # retries keep Webhook-Id and Webhook-Timestamp + "REQ-SHOPPING-ORDER-0025", # MUST retry failed webhook deliveries + "REQ-SHOPPING-ORDER-0026", # same rule as 0018, in Business guidelines + ) def test_transient_failure_retries_preserve_event_identity(self) -> None: """A failed delivery is retried as the same webhook event.""" self.webhook_server.failures_before_success = 1 @@ -247,11 +262,19 @@ def test_transient_failure_retries_preserve_event_identity(self) -> None: ) # ── order.md "Events": fully populated order entity ───────────────────── + @spec_assert( + "REQ-SHOPPING-ORDER-0008", # full entity on every response, delivery too + "REQ-SHOPPING-ORDER-0023", # MUST send "Order created" with full entity + ) def test_order_created_event_is_full_order_entity(self) -> None: """The 'Order created' delivery body is the full order entity.""" checkout_id, order_id, event = self._place_order() self._assert_full_order_entity(event["payload"], checkout_id, order_id) + @spec_assert( + "REQ-SHOPPING-ORDER-0008", # full entity on every response, delivery too + "REQ-SHOPPING-ORDER-0024", # full order entity on updates, not deltas + ) def test_update_event_is_full_order_entity(self) -> None: """An update delivery is the full current-state snapshot, not a delta.""" checkout_id, order_id, _ = self._place_order() @@ -310,6 +333,15 @@ def _signed_event(self) -> dict[str, Any]: ) return event + @spec_assert( + "REQ-SHOPPING-ORDER-0021", # UCP-Agent header with the profile URL + partly( + "REQ-SHOPPING-ORDER-0022", # sign payloads with RFC 9421 headers + "the RFC 9421 headers, their shape and the Content-Digest; " + "cryptographic verification against the business's signing keys is not " + "checked", + ), + ) def test_signed_delivery_carries_required_headers_and_digest(self) -> None: """A signed delivery carries all four headers; the digest matches.""" event = self._signed_event() @@ -347,6 +379,12 @@ def test_signed_delivery_carries_required_headers_and_digest(self) -> None: "Content-Digest does not match the SHA-256 of the raw delivery body", ) + @older_version( + "2026-04-08", + "ucp#659 made webhook signatures also cover webhook-id and " + "webhook-timestamp, and fixed the order example that the ucp-agent skip " + "waits on; the rule is in signatures.md, outside the catalog", + ) def test_signature_covers_ucp_agent(self) -> None: """The signed components include ucp-agent (binds signer identity). diff --git a/shopping/order/webhook_test.py b/shopping/order/webhook_test.py index 670f360..d593ffb 100644 --- a/shopping/order/webhook_test.py +++ b/shopping/order/webhook_test.py @@ -19,7 +19,13 @@ from absl.testing import absltest from framework.base_test import FLAGS -from framework.decorators import requires_capability +from framework.decorators import ( + no_rule, + partly, + requires_capability, + scenario, + spec_assert, +) from framework.mock_webhook_server import MockWebhookServer from shopping.base import ShoppingIntegrationTestBase from ucp_sdk.models.schemas.shopping import checkout @@ -78,6 +84,18 @@ def _deliveries_for(self, order_id: str) -> list[dict[str, Any]]: and e["payload"].get("id") == order_id ] + @spec_assert( + partly( + "REQ-SHOPPING-ORDER-0023", # MUST send "Order created" with full entity + "that a delivery follows completion, not that the entity is fully " + "populated", + ), + partly( + "REQ-SHOPPING-ORDER-0024", # MUST send the full entity on updates + "that an update delivery reflects the shipment, not that it carries " + "the full entity", + ), + ) def test_webhook_event_stream(self) -> None: """Test that completing and then shipping an order each notify. @@ -157,6 +175,11 @@ def test_webhook_event_stream(self) -> None: "no delivery reflected the shipped state in the order data", ) + @scenario( + "the store offers its known customer's stored addresses (fixtures) as " + "destinations, and the order event's expectation carries the one " + "selected; no rule requires either" + ) def test_webhook_order_address_known_customer(self) -> None: """Test that webhook contains correct address for known customer/address.""" customer = self.fixture_ctx.get_known_customer() @@ -279,6 +302,11 @@ def test_webhook_order_address_known_customer(self) -> None: if field in selected_destination: self.assertEqual(destination.get(field), selected_destination[field]) + @no_rule( + "order/index.md, Expectations: an expectation records 'where they're " + "going (destination)'; no keyword says it is the destination selected " + "at checkout" + ) def test_webhook_order_address_new_address(self) -> None: """Test that webhook contains correct address when a new one is provided.""" customer = self.fixture_ctx.get_known_customer() diff --git a/shopping/validation/invalid_input_test.py b/shopping/validation/invalid_input_test.py index 3b55c90..a90fd49 100644 --- a/shopping/validation/invalid_input_test.py +++ b/shopping/validation/invalid_input_test.py @@ -17,7 +17,10 @@ import datetime import uuid from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import ( + requires_capability, + scenario, +) from shopping.base import ShoppingIntegrationTestBase from ucp_sdk.models.schemas.shopping import checkout as checkout from ucp_sdk.models.schemas.shopping import order @@ -44,6 +47,10 @@ class InvalidInputTest(ShoppingIntegrationTestBase): - PUT /orders/{id} """ + @scenario( + "sends an invalid adjustment status through PUT /orders/{id}, the sample " + "server's own endpoint; the spec defines only GET /orders/{id}" + ) def test_invalid_adjustment_status(self): """Test that an invalid adjustment status is rejected. @@ -85,6 +92,10 @@ def test_invalid_adjustment_status(self): # Pydantic validation error should result in 422 self.assert_response_status(resp, 422) + @scenario( + "sends adjustments as an object through PUT /orders/{id}, the sample " + "server's own endpoint; the spec defines only GET /orders/{id}" + ) def test_malformed_adjustment_payload(self): """Test that malformed adjustment payloads are rejected. diff --git a/shopping/validation/validation_test.py b/shopping/validation/validation_test.py index bf1474f..983016d 100644 --- a/shopping/validation/validation_test.py +++ b/shopping/validation/validation_test.py @@ -15,7 +15,10 @@ """Validation tests for the UCP SDK Server.""" from absl.testing import absltest -from framework.decorators import requires_capability +from framework.decorators import ( + requires_capability, + spec_assert, +) from shopping.base import get_valid_payment_payload from shopping.base import ShoppingIntegrationTestBase from ucp_sdk.models.schemas.shopping import ( @@ -209,6 +212,9 @@ def assert_4xx_error( self.assert_response_status(response, expected_status) self._assert_structured_4xx_error(response, substring) + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0105", # SHOULD provide accurate error messages + ) def test_out_of_stock(self) -> None: """Test validation for out-of-stock items. @@ -242,6 +248,9 @@ def test_out_of_stock(self) -> None: error_4xx_substring="stock", ) + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0105", # SHOULD provide accurate error messages + ) def test_update_inventory_validation(self) -> None: """Test that inventory validation is enforced on update. @@ -319,6 +328,9 @@ def test_update_inventory_validation(self) -> None: error_4xx_substring="stock", ) + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0105", # SHOULD provide accurate error messages + ) def test_product_not_found(self) -> None: """Test validation for non-existent products. @@ -351,6 +363,9 @@ def test_product_not_found(self) -> None: error_4xx_substring="not found", ) + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0105", # SHOULD provide accurate error messages + ) def test_payment_failure(self) -> None: """Test handling of payment failures. @@ -382,6 +397,9 @@ def test_payment_failure(self) -> None: error_4xx_substring="payment", ) + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0105", # SHOULD provide accurate error messages + ) @requires_capability("dev.ucp.shopping.fulfillment") def test_complete_without_fulfillment(self) -> None: """Test completion rejection when fulfillment is missing. @@ -409,6 +427,9 @@ def test_complete_without_fulfillment(self) -> None: error_4xx_substring="fulfillment", ) + @spec_assert( + "REQ-SHOPPING-CHECKOUT-0105", # SHOULD provide accurate error messages + ) def test_structured_error_messages(self) -> None: """Test that error responses carry structured, machine-readable detail. diff --git a/tests/build_catalog_test.py b/tests/build_catalog_test.py new file mode 100644 index 0000000..9c42fc0 --- /dev/null +++ b/tests/build_catalog_test.py @@ -0,0 +1,570 @@ +# Copyright 2026 UCP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Unit tests for the release history in requirements/tools/build_catalog.py. + +The tool is a script, not a package, so it is loaded from its path. These +tests need neither the extractor nor a specification checkout; the one that +reads a release from git builds a small repository of its own. +""" + +import hashlib +import importlib.util +import json +from pathlib import Path +import subprocess +import sys +import tempfile +import unittest + +_TOOL = ( + Path(__file__).resolve().parents[1] + / "requirements" + / "tools" + / "build_catalog.py" +) +_SPEC = importlib.util.spec_from_file_location("build_catalog", _TOOL) +build_catalog = importlib.util.module_from_spec(_SPEC) +sys.modules["build_catalog"] = build_catalog +_SPEC.loader.exec_module(build_catalog) + +CHECKOUT_PAGE = "docs/specification/shopping/checkout/index.md" +CHECKOUT_REST = "docs/specification/shopping/checkout/rest.md" +CART_PAGE = "docs/specification/shopping/cart/index.md" +VERSIONS = ("2026-01-11", "2026-04-08", "draft") +COMMIT = "f" * 40 + + +def wording( + text: str, file: str = CHECKOUT_PAGE, context: str | None = None +) -> "build_catalog.Wording": + """Return a wording, with a digest of its context and text.""" + joined = f"{context or ''}\x1f{text}" + digest = hashlib.sha256(joined.encode("utf-8")).hexdigest()[:10] + return build_catalog.Wording(file, digest, context, text) + + +def stated( + version: str, + text: str, + file: str = CHECKOUT_PAGE, + context: str | None = None, + line: int = 1, + level: str = "MUST", +) -> "build_catalog.Stated": + """Return a rule as a release states it, on a page under its old name.""" + return build_catalog.Stated( + version=version, + wording=wording(text, file, context), + position=(line, line), + file=file.replace("shopping/checkout/index.md", "checkout.md"), + level=level, + prefix="REQ-SHOPPING-CHECKOUT", + record={"clause": f"The business {text}."}, + ) + + +def same_capability(page: str, other: str) -> bool: + """Return whether two test pages belong to one capability.""" + return Path(page).parent == Path(other).parent + + +class MatchReleaseTest(unittest.TestCase): + """Tests for match_release.""" + + def test_same_wording(self): + """Test a rule found word for word on its page.""" + text = "must return the checkout" + self.assertEqual( + build_catalog.match_release( + [stated("2026-04-08", text)], {"REQ-1": wording(text)} + ), + [("REQ-1", build_catalog.SAME_WORDING)], + ) + + def test_moved_to_a_related_page(self): + """Test a rule that moved, but only between related pages.""" + text = "must return the checkout" + candidates = {"REQ-1": wording(text, CHECKOUT_REST)} + rules = [stated("2026-04-08", text)] + self.assertEqual( + build_catalog.match_release(rules, candidates, same_capability), + [("REQ-1", build_catalog.OTHER_PAGE)], + ) + elsewhere = {"REQ-1": wording(text, CART_PAGE)} + self.assertEqual( + build_catalog.match_release(rules, elsewhere, same_capability), [None] + ) + + def test_other_list_stem(self): + """Test the same wording under another stem, if it is long enough.""" + long_text = "must distinguish this option from its siblings" + self.assertEqual( + build_catalog.match_release( + [stated("2026-01-11", long_text)], + {"REQ-1": wording(long_text, context="for options[].title")}, + ), + [("REQ-1", build_catalog.OTHER_STEM)], + ) + # A matrix cell reads just "must": its stem tells it apart. + self.assertEqual( + build_catalog.match_release( + [stated("2026-01-11", "must", context="create")], + {"REQ-1": wording("must", context="cancel")}, + ), + [None], + ) + + def test_reworded(self): + """Test a reworded rule, at least 85% alike, and one that isn't.""" + self.assertEqual( + build_catalog.match_release( + [stated("2026-08-25", "business must use cart contents")], + {"REQ-1": wording("the business must use the cart contents")}, + ), + [("REQ-1", build_catalog.REWORDED)], + ) + self.assertEqual( + build_catalog.match_release( + [stated("2026-08-25", "must sign the payload with a JWT")], + {"REQ-1": wording("must sign the payload per RFC 9421")}, + ), + [None], + ) + + def test_one_rule_per_candidate(self): + """Test that two copies of a wording take one candidate each.""" + text = "must return the checkout" + rules = [ + stated("2026-04-08", text, line=1), + stated("2026-04-08", text, line=2), + ] + self.assertEqual( + build_catalog.match_release(rules, {"REQ-1": wording(text)}), + [("REQ-1", build_catalog.SAME_WORDING), None], + ) + self.assertEqual( + build_catalog.match_release( + rules, {"REQ-2": wording(text), "REQ-1": wording(text)} + ), + [ + ("REQ-1", build_catalog.SAME_WORDING), + ("REQ-2", build_catalog.SAME_WORDING), + ], + ) + + +class TraceHistoryTest(unittest.TestCase): + """Tests for trace_history.""" + + def setUp(self): + """Set up one rule of the pinned spec, and two releases.""" + super().setUp() + self.kept = "must return the full checkout on every response" + self.reworded = "must return the checkout on every response" + self.gone = "must sign webhooks with a detached jws signature" + self.moved = "must include the ucp-agent header on every request" + self.current = {"REQ-SHOPPING-CHECKOUT-0001": wording(self.kept)} + self.outside = [wording(self.moved, "docs/specification/overview.md")] + self.stated = { + "2026-04-08": [ + stated("2026-04-08", self.kept), + stated("2026-04-08", self.gone, line=2), + ], + "2026-01-11": [ + stated("2026-01-11", self.reworded), + stated("2026-01-11", self.gone, line=2), + stated("2026-01-11", self.moved, line=3), + ], + } + + def test_trace(self): + """Test kept, reworded, removed and moved rules, newest release first.""" + history = build_catalog.trace_history( + VERSIONS, self.stated, self.current, self.outside + ) + kept = history.stated["REQ-SHOPPING-CHECKOUT-0001"] + self.assertEqual( + [(s.version, s.wording.text) for s in kept], + [("2026-01-11", self.reworded), ("2026-04-08", self.kept)], + ) + self.assertEqual(history.removed, ["~00000"]) + self.assertEqual( + [s.version for s in history.stated["~00000"]], + ["2026-01-11", "2026-04-08"], + ) + self.assertEqual( + [(rule.wording.text, pages) for rule, pages in history.moved_out], + [(self.moved, ["docs/specification/overview.md"])], + ) + self.assertEqual( + dict(history.matched["2026-04-08"]), + {build_catalog.SAME_WORDING: 1, build_catalog.LAST_STATED: 1}, + ) + self.assertEqual( + dict(history.matched["2026-01-11"]), + { + build_catalog.REWORDED: 1, + build_catalog.SAME_WORDING: 1, + build_catalog.MOVED_OUT: 1, + }, + ) + rule, key, newer, alike = history.reworded[0] + self.assertEqual( + (rule.wording.text, key, newer.text), + (self.reworded, "REQ-SHOPPING-CHECKOUT-0001", self.kept), + ) + self.assertGreaterEqual(alike, build_catalog.REWORD_SIMILARITY) + + def test_split(self): + """Test that a split makes the older wording a rule of its own.""" + history = build_catalog.trace_history( + VERSIONS, + self.stated, + self.current, + self.outside, + splits={"REQ-SHOPPING-CHECKOUT-0001": "2026-04-08"}, + ) + self.assertEqual( + [s.version for s in history.stated["REQ-SHOPPING-CHECKOUT-0001"]], + ["2026-04-08"], + ) + self.assertEqual(len(history.removed), 2) + self.assertEqual(history.split, {"REQ-SHOPPING-CHECKOUT-0001"}) + + def test_split_that_changes_nothing(self): + """Test that a split with no older wording to split off isn't noted.""" + history = build_catalog.trace_history( + VERSIONS, + self.stated, + self.current, + self.outside, + splits={"REQ-SHOPPING-CHECKOUT-0001": "2026-01-11"}, + ) + self.assertEqual(history.split, set()) + + +class AssignRemovedIdsTest(unittest.TestCase): + """Tests for assign_removed_ids.""" + + def test_reuses_and_mints(self): + """Test a retired ID reused by wording, and a new one minted after it.""" + old = wording("must sign webhooks with a detached jws signature") + entries = [ + { + "id": "REQ-SHOPPING-CHECKOUT-0001", + "file": CHECKOUT_PAGE, + "text_digest": "aaaaaaaaaa", + "context": None, + "text": "must return the checkout", + "previous_digests": [], + "status": "active", + "minted_at": COMMIT, + "retired_at": None, + }, + { + "id": "REQ-SHOPPING-CHECKOUT-0002", + "file": CHECKOUT_PAGE, + "text_digest": old.text_digest, + "context": None, + "text": old.text, + "previous_digests": [], + "status": "retired", + "minted_at": COMMIT, + "retired_at": COMMIT, + }, + ] + before = json.dumps(entries) + removed = [ + [stated("2026-01-11", old.text)], + [ + stated("2026-01-11", "must answer within five seconds"), + stated("2026-01-23", "must answer within ten seconds"), + ], + ] + ids, after, minted = build_catalog.assign_removed_ids( + removed, entries, COMMIT + ) + self.assertEqual( + ids, ["REQ-SHOPPING-CHECKOUT-0002", "REQ-SHOPPING-CHECKOUT-0003"] + ) + self.assertEqual(minted, ["REQ-SHOPPING-CHECKOUT-0003"]) + self.assertEqual(json.dumps(entries), before) + new = after[-1] + self.assertEqual( + (new["id"], new["status"], new["minted_at"], new["retired_at"]), + ("REQ-SHOPPING-CHECKOUT-0003", "retired", COMMIT, COMMIT), + ) + self.assertEqual(new["text"], "must answer within ten seconds") + self.assertEqual( + new["previous_digests"], + [wording("must answer within five seconds").text_digest], + ) + + +class LifespanTest(unittest.TestCase): + """Tests for lifespan, statements and removed_record.""" + + versions = ("2026-01-11", "2026-01-23", "2026-04-08", "2026-08-25", "draft") + + def test_lifespan(self): + """Test since and until, with None while the draft states the rule.""" + cases = { + ("2026-01-11", "2026-01-23"): ("2026-01-11", "2026-04-08"), + ("2026-08-25",): ("2026-08-25", "draft"), + ("2026-04-08", "draft"): ("2026-04-08", None), + ("draft",): ("draft", None), + } + for stated_in, expected in cases.items(): + with self.subTest(stated_in): + self.assertEqual( + build_catalog.lifespan(stated_in, self.versions), expected + ) + + def test_statements_and_removed_record(self): + """Test that a statement gives its wording only when it differs.""" + rules = [ + stated("2026-01-11", "must answer within five seconds"), + stated("2026-01-23", "must answer within ten seconds", line=7), + ] + entries = build_catalog.statements(rules, rules[1].wording.text_digest) + self.assertEqual( + entries[0]["clause"], "The business must answer within five seconds." + ) + self.assertNotIn("clause", entries[1]) + self.assertEqual( + (entries[1]["version"], entries[1]["file"], entries[1]["start_line"]), + ("2026-01-23", "docs/specification/checkout.md", 7), + ) + rules[1].record.update( + id="REQ-POSITIONAL-01", + text_digest=rules[1].wording.text_digest, + source={"file": CHECKOUT_PAGE, "page": "x/"}, + suite={}, + ) + record = build_catalog.removed_record( + rules, "REQ-SHOPPING-CHECKOUT-0009", self.versions, lambda f: f"p:{f}" + ) + self.assertEqual(record["id"], "REQ-SHOPPING-CHECKOUT-0009") + self.assertEqual( + record["source"], + { + "file": "docs/specification/checkout.md", + "page": "p:docs/specification/checkout.md", + }, + ) + self.assertEqual( + (record["suite"]["since"], record["suite"]["until"]), + ("2026-01-11", "2026-04-08"), + ) + self.assertEqual(len(record["suite"]["releases"]), 2) + self.assertEqual(rules[1].record["id"], "REQ-POSITIONAL-01") + + +class InputsTest(unittest.TestCase): + """Tests for load_releases and load_splits.""" + + def write(self, document: dict[str, object]) -> Path: + """Write a JSON file to a temporary directory and return its path.""" + directory = tempfile.TemporaryDirectory() + self.addCleanup(directory.cleanup) + path = Path(directory.name) / "input.json" + path.write_text(json.dumps(document), encoding="utf-8") + return path + + def test_load_releases(self): + """Test a releases file, and the problems a malformed one has.""" + good = { + "releases": [ + {"version": "2026-01-11", "ref": "release/2026-01-11", "commit": COMMIT} + ], + "flat_pages": {"checkout.md": "shopping/checkout/index.md"}, + "other_pages": ["overview.md"], + } + problems = [] + config = build_catalog.load_releases(self.write(good), problems) + self.assertEqual(problems, []) + self.assertEqual(config.versions, ("2026-01-11", "draft")) + bad = { + "releases": [ + {"version": "2026-04-08", "ref": "r", "commit": "abc"}, + {"version": "2026-01-11", "ref": "r", "commit": COMMIT}, + ], + "flat_pages": {"overview.md": "overview/index.md"}, + "other_pages": [], + } + build_catalog.load_releases(self.write(bad), problems) + self.assertEqual(len(problems), 3) + problems.clear() + build_catalog.load_releases(self.write({"releases": []}), problems) + self.assertEqual(len(problems), 1) + + def test_load_splits(self): + """Test the review's splits, and malformed ones.""" + problems = [] + splits = build_catalog.load_splits( + self.write( + { + "decisions": [], + "splits": [ + { + "id": "REQ-SHOPPING-CHECKOUT-0001", + "before": "2026-04-08", + "reason": "the older wording allowed a 4xx", + }, + {"id": "REQ-SHOPPING-CHECKOUT-0002", "before": "2026-04-08"}, + {"id": "not an ID", "before": "draft", "reason": "r"}, + ], + } + ), + problems, + ) + self.assertEqual(splits, {"REQ-SHOPPING-CHECKOUT-0001": "2026-04-08"}) + self.assertEqual(len(problems), 2) + + +class StageReleaseTest(unittest.TestCase): + """Tests for stage_release, against a small git repository.""" + + def setUp(self): + """Commit a flat release layout to a new repository.""" + super().setUp() + directory = tempfile.TemporaryDirectory() + self.addCleanup(directory.cleanup) + self.root = Path(directory.name) + self.repo = self.root / "repo" + files = { + "mkdocs.yml": "extra:\n ucp_version: 2026-01-11\n", + "docs/specification/checkout.md": "# Checkout\n", + "docs/specification/overview.md": "# Overview\n", + "docs/specification/mystery.md": "# Mystery\n", + "source/schemas/shopping/checkout.json": "{}\n", + } + for name, text in files.items(): + path = self.repo / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(text, encoding="utf-8") + self.git("init", "--quiet") + self.git("add", ".") + self.git( + "-c", + "user.name=Test", + "-c", + "user.email=test@example.com", + "-c", + "commit.gpgsign=false", + "commit", + "--quiet", + "-m", + "release", + ) + self.commit = self.git("rev-parse", "HEAD").strip() + + def git(self, *args: str) -> str: + """Run git in the test repository.""" + return subprocess.run( + ["git", "-C", str(self.repo), *args], + capture_output=True, + text=True, + check=True, + ).stdout + + def test_moves_mapped_pages(self): + """Test that shopping pages move to today's paths, and others are kept.""" + config = build_catalog.ReleaseConfig( + releases=(build_catalog.Release("2026-01-11", "r", self.commit),), + flat_pages={"checkout.md": "shopping/checkout/index.md"}, + other_pages=("over*.md",), + ) + dest = self.root / "staged" + dest.mkdir() + moved, unknown = build_catalog.stage_release( + self.repo, config.releases[0], config, dest + ) + self.assertEqual(moved, {CHECKOUT_PAGE: "docs/specification/checkout.md"}) + self.assertEqual(unknown, ["mystery.md"]) + self.assertTrue((dest / CHECKOUT_PAGE).is_file()) + self.assertTrue((dest / "source/schemas/shopping/checkout.json").is_file()) + + def test_missing_commit(self): + """Test that a commit the clone doesn't have is an error.""" + release = build_catalog.Release("2026-01-11", "r", "0" * 40) + with self.assertRaises(subprocess.CalledProcessError): + build_catalog.stage_release( + self.repo, release, build_catalog.ReleaseConfig(), self.root + ) + + +class GitCommitTest(unittest.TestCase): + """Tests for scoping git_commit to the extractor directory.""" + + def setUp(self): + """Create a small repository with an extractor subtree and another file.""" + super().setUp() + directory = tempfile.TemporaryDirectory() + self.addCleanup(directory.cleanup) + self.repo = Path(directory.name) / "github" + self.scripts = ( + self.repo / "org-tools" / "requirements-extractor" / "scripts" + ) + self.scripts.mkdir(parents=True) + (self.scripts.parent / "pyproject.toml").write_text("[project]\n", "utf-8") + (self.scripts / "tool.py").write_text("x = 1\n", "utf-8") + self._git("init", "--quiet") + self._git("add", ".") + self._commit("add extractor") + self.extractor_sha = self._git("rev-parse", "HEAD").strip() + + def _git(self, *args: str) -> str: + return subprocess.run( + ["git", "-C", str(self.repo), *args], + capture_output=True, + text=True, + check=True, + ).stdout + + def _commit(self, message: str) -> None: + self._git( + "-c", + "user.name=Test", + "-c", + "user.email=test@example.com", + "-c", + "commit.gpgsign=false", + "commit", + "--quiet", + "-m", + message, + ) + + def test_ignores_commits_outside_extractor_tree(self): + """Unrelated repository commits do not advance extractor_commit.""" + (self.repo / "MAINTAINERS.md").write_text("# Maintainers\n", "utf-8") + self._git("add", "MAINTAINERS.md") + self._commit("unrelated doc change") + + tree = build_catalog.extractor_tree(self.scripts) + self.assertEqual(tree, self.scripts.resolve().parent) + self.assertEqual( + build_catalog.git_commit(tree), (self.extractor_sha, False) + ) + + (self.scripts.parent / "pyproject.toml").write_text( + "[project]\nversion = '2'\n", "utf-8" + ) + self.assertEqual(build_catalog.git_commit(tree), (self.extractor_sha, True)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/decorators_test.py b/tests/decorators_test.py new file mode 100644 index 0000000..b2533d4 --- /dev/null +++ b/tests/decorators_test.py @@ -0,0 +1,240 @@ +# Copyright 2026 UCP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Unit tests for the specification markers in framework.decorators.""" + +import unittest + +from framework.decorators import ( + SpecMarker, + no_rule, + older_version, + outside_catalog, + partly, + scenario, + spec_assert, + spec_marker, +) + +RULE = "REQ-SHOPPING-CHECKOUT-0133" +OTHER_RULE = "REQ-SHOPPING-CHECKOUT-0134" + + +class SpecAssertTest(unittest.TestCase): + """Tests for spec_assert.""" + + def test_records_rule_ids_in_order(self): + """Test that the marker keeps the rule IDs in the order given.""" + + @spec_assert(OTHER_RULE, RULE) + def test_method(): + pass + + self.assertEqual( + spec_marker(test_method), + SpecMarker("spec_assert", rule_ids=(OTHER_RULE, RULE)), + ) + + def test_returns_the_same_function(self): + """Test that the marker labels the test without wrapping it.""" + + def test_method(): + return "ran" + + self.assertIs(spec_assert(RULE)(test_method), test_method) + self.assertEqual(test_method(), "ran") + + def test_rejects_bad_ids(self): + """Test that a missing, malformed or repeated ID fails at once.""" + for rule_ids in ( + (), + ("REQ-SHOPPING-CHECKOUT",), + ("req-shopping-checkout-0133",), + ("Totals", RULE), + (133,), + (RULE, RULE), + ): + with self.subTest(rule_ids=rule_ids), self.assertRaises(ValueError): + spec_assert(*rule_ids) + + def test_records_partial_claims(self): + """Test that partly() rules are cited in order, each with its gap.""" + + @spec_assert(RULE, partly(OTHER_RULE, " whole numbers only ")) + def test_method(): + pass + + marker = spec_marker(test_method) + self.assertEqual( + marker, + SpecMarker( + "spec_assert", + rule_ids=(RULE, OTHER_RULE), + gaps=((OTHER_RULE, "whole numbers only"),), + ), + ) + self.assertEqual(marker.partial_ids, frozenset({OTHER_RULE})) + self.assertEqual( + SpecMarker("spec_assert", rule_ids=(RULE,)).partial_ids, frozenset() + ) + + def test_rejects_bad_partial_claims(self): + """Test that an empty gap, a bad ID or a rule cited twice fails.""" + for gap in ("", " ", None): + with self.subTest(gap=gap), self.assertRaises(ValueError): + partly(RULE, gap) + for claims in ( + (partly("REQ-SHOPPING-CHECKOUT", "a gap"),), + (RULE, partly(RULE, "a gap")), + (partly(RULE, "a gap"), partly(RULE, "another gap")), + ): + with self.subTest(claims=claims), self.assertRaises(ValueError): + spec_assert(*claims) + + +class ReasonMarkerTest(unittest.TestCase): + """Tests for the markers that take only a reason.""" + + MARKERS = ( + (no_rule, "no_rule"), + (scenario, "scenario"), + (outside_catalog, "outside_catalog"), + ) + + def test_records_the_reason(self): + """Test that each marker keeps its kind and its trimmed reason.""" + for marker, kind in self.MARKERS: + with self.subTest(kind=kind): + + @marker(" described in discount.md without a keyword ") + def test_method(): + pass + + self.assertEqual( + spec_marker(test_method), + SpecMarker(kind, reason="described in discount.md without a keyword"), + ) + + def test_rejects_an_empty_reason(self): + """Test that a marker without a reason fails at once.""" + for marker, _ in self.MARKERS: + for reason in ("", " ", None): + with ( + self.subTest(marker=marker.__name__, reason=reason), + self.assertRaises(ValueError), + ): + marker(reason) + + +class OlderVersionTest(unittest.TestCase): + """Tests for older_version.""" + + def test_records_the_version_and_reason(self): + """Test that the marker keeps the release and what changed.""" + + @older_version("2026-04-08", "consent purposes became reverse-DNS IDs") + def test_method(): + pass + + self.assertEqual( + spec_marker(test_method), + SpecMarker( + "older_version", + reason="consent purposes became reverse-DNS IDs", + version="2026-04-08", + ), + ) + + def test_rejects_a_bad_version_or_reason(self): + """Test that a version that is not a release date, or no reason, fails.""" + for version, reason in ( + ("April 2026", "a reason"), + ("2026-4-8", "a reason"), + ("", "a reason"), + ("2026-04-08", " "), + ): + with ( + self.subTest(version=version, reason=reason), + self.assertRaises(ValueError), + ): + older_version(version, reason) + + +class LabellingTest(unittest.TestCase): + """Tests that hold for every marker.""" + + def test_one_marker_per_test(self): + """Test that a second marker on the same test fails at once.""" + + @spec_assert(RULE) + def test_method(): + pass + + for second in ( + spec_assert(OTHER_RULE), + no_rule("a reason"), + scenario("a reason"), + outside_catalog("a reason"), + older_version("2026-04-08", "a reason"), + ): + with self.subTest(second=second), self.assertRaises(ValueError): + second(test_method) + + def test_labels_methods_only(self): + """Test that a marker on a class fails: each test cites its own rules.""" + with self.assertRaises(TypeError): + + @spec_assert(RULE) + class Marked(unittest.TestCase): + pass + + def test_unmarked_test_has_no_marker(self): + """Test that spec_marker returns None for a test without a marker.""" + + def test_method(): + pass + + self.assertIsNone(spec_marker(test_method)) + + def test_marked_tests_run_as_before(self): + """Test that unittest runs marked tests unchanged, markers readable.""" + + class Example(unittest.TestCase): + @spec_assert(RULE) + def test_passes(self): + """Pass.""" + + @no_rule("described without a keyword") + def test_fails(self): + """Fail.""" + self.fail("fails as written") + + loaded = list(unittest.defaultTestLoader.loadTestsFromTestCase(Example)) + result = unittest.TestResult() + unittest.TestSuite(loaded).run(result) + self.assertEqual((result.testsRun, len(result.failures)), (2, 1)) + markers = {test._testMethodName: spec_marker(test) for test in loaded} + self.assertEqual(markers["test_passes"].rule_ids, (RULE,)) + self.assertEqual(markers["test_fails"].kind, "no_rule") + + def test_reexported_from_framework_package(self): + """Test that framework re-exports partly alongside the marker decorators.""" + import framework + + self.assertIs(framework.partly, partly) + self.assertIn("partly", framework.__all__) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/marker_check_test.py b/tests/marker_check_test.py new file mode 100644 index 0000000..493b9d3 --- /dev/null +++ b/tests/marker_check_test.py @@ -0,0 +1,324 @@ +# Copyright 2026 UCP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Unit tests for the marker check in framework.marker_check.""" + +import dataclasses +import tempfile +from types import MappingProxyType, SimpleNamespace +import unittest + +from framework import marker_check +from framework.decorators import ( + SpecMarker, + requires_capability, + spec_assert, +) +from framework.marker_check import LoadedTest +from framework.requirements import Catalog, Rule, Statement + +CART = "dev.ucp.shopping.cart" +CHECKOUT = "dev.ucp.shopping.checkout" +DISCOUNT = "dev.ucp.shopping.discount" +ORDER = "dev.ucp.shopping.order" + + +def rule( + rule_id: str, capability: str, testable: bool = True, is_rule: bool = True +) -> Rule: + """Return a rule of one capability.""" + return Rule( + id=rule_id, + level="MUST", + clause="The business MUST do it.", + capabilities=(capability,), + source_file="docs/specification/shopping/checkout/index.md", + line=1, + link="specification/shopping/checkout/#a", + testable=testable, + testable_reason="aimed at the business" if testable else "MCP page", + is_rule=is_rule, + ) + + +CATALOG = Catalog( + rules=MappingProxyType( + { + "REQ-SHOPPING-CHECKOUT-0001": rule( + "REQ-SHOPPING-CHECKOUT-0001", CHECKOUT + ), + "REQ-SHOPPING-CHECKOUT-0002": rule( + "REQ-SHOPPING-CHECKOUT-0002", CHECKOUT, testable=False + ), + "REQ-SHOPPING-CHECKOUT-0003": rule( + "REQ-SHOPPING-CHECKOUT-0003", CHECKOUT, is_rule=False + ), + "REQ-SHOPPING-CART-0001": rule("REQ-SHOPPING-CART-0001", CART), + } + ), + retired=frozenset({"REQ-SHOPPING-CHECKOUT-0004"}), + extends=MappingProxyType({DISCOUNT: (CART, CHECKOUT)}), +) + + +def loaded( + name: str, + marker: SpecMarker | None, + capabilities: frozenset[str] = frozenset({CHECKOUT}), + module: str = "shopping.checkout.example_test", +) -> LoadedTest: + """Return a loaded test.""" + return LoadedTest( + f"{module}.ExampleTest.{name}", module, marker, capabilities + ) + + +def cites(*rule_ids: str) -> SpecMarker: + """Return a spec_assert marker.""" + return SpecMarker("spec_assert", rule_ids=rule_ids) + + +class CheckTest(unittest.TestCase): + """Tests for check.""" + + def test_counts_markers_and_cited_rules(self): + """Test the counts, the rules cited, and that other suites are skipped.""" + result = marker_check.check( + [ + loaded("test_cites", cites("REQ-SHOPPING-CHECKOUT-0001")), + loaded("test_no_rule", SpecMarker("no_rule", reason="r")), + loaded("test_scenario", SpecMarker("scenario", reason="r")), + loaded("test_core_rule", SpecMarker("outside_catalog", reason="r")), + loaded( + "test_old", + SpecMarker("older_version", reason="r", version="2026-04-08"), + ), + loaded("test_unmarked", None), + loaded("test_core", None, module="core.protocol_test"), + ], + CATALOG, + ) + self.assertEqual(result.checked, 6) + self.assertEqual( + dict(result.kinds), + { + "spec_assert": 1, + "no_rule": 1, + "scenario": 1, + "outside_catalog": 1, + "older_version": 1, + "unmarked": 1, + }, + ) + self.assertEqual(result.rules, {"REQ-SHOPPING-CHECKOUT-0001"}) + self.assertEqual(len(result.problems), 1) + self.assertIn("test_unmarked: no marker", result.problems[0]) + self.assertEqual(result.warnings, []) + self.assertIn( + "1 cite rules (1 distinct rules), 1 no_rule, 1 scenario, " + "1 outside_catalog, 1 older_version, 1 unmarked", + result.report(), + ) + + def test_problems_for_ids_a_test_must_not_cite(self): + """Test that unknown, retired and not-a-rule IDs are problems.""" + result = marker_check.check( + [ + loaded( + "test_cites", + cites( + "REQ-SHOPPING-CHECKOUT-0099", + "REQ-SHOPPING-CHECKOUT-0004", + "REQ-SHOPPING-CHECKOUT-0003", + ), + ) + ], + CATALOG, + ) + self.assertEqual( + [problem.split(": ", 1)[1] for problem in result.problems], + [ + "REQ-SHOPPING-CHECKOUT-0099 is not in the catalog", + "REQ-SHOPPING-CHECKOUT-0004 is retired: its rule was removed or " + "rewritten", + "REQ-SHOPPING-CHECKOUT-0003 is a sentence the review found states no " + "requirement", + ], + ) + self.assertEqual(result.rules, set()) + + def test_warnings(self): + """Test the warnings for untestable rules and other capabilities.""" + result = marker_check.check( + [ + loaded("test_untestable", cites("REQ-SHOPPING-CHECKOUT-0002")), + loaded( + "test_other_capability", + cites("REQ-SHOPPING-CART-0001"), + capabilities=frozenset({ORDER}), + ), + # A discount test exercises checkout, which discount extends. + loaded( + "test_parent", + cites("REQ-SHOPPING-CHECKOUT-0001"), + capabilities=frozenset({DISCOUNT}), + ), + # A test that requires no capability is not compared. + loaded( + "test_no_capability", + cites("REQ-SHOPPING-CART-0001"), + capabilities=frozenset(), + ), + ], + CATALOG, + ) + self.assertEqual(result.problems, []) + self.assertEqual(len(result.warnings), 2) + self.assertIn( + "test_untestable: REQ-SHOPPING-CHECKOUT-0002 is not", result.warnings[0] + ) + self.assertIn( + f"test_other_capability: REQ-SHOPPING-CART-0001 belongs to {CART}", + result.warnings[1], + ) + + def test_removed_rule(self): + """Test that a removed rule may be cited, with a warning.""" + removed = dataclasses.replace( + rule("REQ-SHOPPING-CHECKOUT-0005", CHECKOUT), + since="2026-01-11", + until="2026-04-08", + statements=( + Statement("2026-01-11", "MUST", "The business MUST do it.", "a.md", 1), + Statement("2026-01-23", "MUST", "The business MUST do it.", "a.md", 2), + ), + ) + catalog = dataclasses.replace( + CATALOG, + retired=CATALOG.retired | {removed.id}, + removed=MappingProxyType({removed.id: removed}), + ) + result = marker_check.check( + [ + loaded( + "test_old", + cites("REQ-SHOPPING-CHECKOUT-0005", "REQ-SHOPPING-CHECKOUT-0004"), + ) + ], + catalog, + ) + self.assertEqual(result.rules, {"REQ-SHOPPING-CHECKOUT-0005"}) + self.assertEqual( + result.warnings, + [ + f"{loaded('test_old', None).test_id}: REQ-SHOPPING-CHECKOUT-0005 was " + "removed in 2026-04-08; only 2026-01-11, 2026-01-23 state it" + ], + ) + # A retired ID without a history still names nothing to cite. + self.assertEqual(len(result.problems), 1) + self.assertIn("REQ-SHOPPING-CHECKOUT-0004 is retired", result.problems[0]) + + +class EvaluateTest(unittest.TestCase): + """Tests for evaluate, against this repository's catalog.""" + + def test_modes(self): + """Test that only strict mode stops the run, and off checks nothing.""" + tests = [loaded("test_unmarked", None)] + report, stop = marker_check.evaluate(tests, "strict") + self.assertTrue(stop) + self.assertIn("1 unmarked", report) + self.assertEqual(marker_check.evaluate(tests, "warn"), (report, False)) + self.assertEqual(marker_check.evaluate(tests, "off"), ("", False)) + + def test_nothing_to_check(self): + """Test that tests outside the shopping suite need no catalog.""" + tests = [loaded("test_core", None, module="core.protocol_test")] + self.assertEqual( + marker_check.evaluate(tests, "strict", catalog_dir="/nonexistent"), + ("", False), + ) + + def test_missing_catalog(self): + """Test that a missing catalog stops a strict run only.""" + tests = [loaded("test_cites", cites("REQ-SHOPPING-CHECKOUT-0001"))] + with tempfile.TemporaryDirectory() as empty: + report, stop = marker_check.evaluate(tests, "strict", catalog_dir=empty) + self.assertTrue(stop) + self.assertIn("no catalog", report) + self.assertFalse( + marker_check.evaluate(tests, "warn", catalog_dir=empty)[1] + ) + + +class DescribeTest(unittest.TestCase): + """Tests for describing tests from unittest and from pytest.""" + + def test_from_unittest(self): + """Test the marker and capabilities read from a loaded test case.""" + + @requires_capability(CHECKOUT) + class Example(unittest.TestCase): + @requires_capability(DISCOUNT) + @spec_assert("REQ-SHOPPING-CHECKOUT-0001") + def test_one(self): + """Do nothing.""" + + (test,) = unittest.defaultTestLoader.loadTestsFromTestCase(Example) + described = marker_check.from_unittest(test) + self.assertEqual(described.module, __name__) + self.assertEqual(described.marker, cites("REQ-SHOPPING-CHECKOUT-0001")) + self.assertEqual(described.capabilities, {CHECKOUT, DISCOUNT}) + + def test_from_pytest_item(self): + """Test the fields read from a collected pytest item.""" + + @spec_assert("REQ-SHOPPING-CHECKOUT-0001") + def test_one(): + pass + + item = SimpleNamespace( + nodeid="shopping/checkout/x_test.py::X::test_one", + module=SimpleNamespace(__name__="shopping.checkout.x_test"), + cls=SimpleNamespace(_required_capabilities={(CHECKOUT, None)}), + obj=test_one, + ) + self.assertEqual( + marker_check.from_pytest_item(item), + LoadedTest( + "shopping/checkout/x_test.py::X::test_one", + "shopping.checkout.x_test", + cites("REQ-SHOPPING-CHECKOUT-0001"), + frozenset({CHECKOUT}), + ), + ) + + def test_runner_accepts_both_flag_spellings(self): + """Test that runner.parse_args accepts underscore and hyphen spellings.""" + import runner + + self.assertEqual(runner.parse_args([]).requirements_check, "strict") + self.assertEqual( + runner.parse_args(["--requirements_check=warn"]).requirements_check, + "warn", + ) + self.assertEqual( + runner.parse_args(["--requirements-check=off"]).requirements_check, + "off", + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/requirements_test.py b/tests/requirements_test.py new file mode 100644 index 0000000..8c36609 --- /dev/null +++ b/tests/requirements_test.py @@ -0,0 +1,420 @@ +# Copyright 2026 UCP Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Unit tests for the catalog loader in framework.requirements. + +Most use a small catalog written to a temporary directory; the last class +reads this repository's catalog. +""" + +import json +from pathlib import Path +import tempfile +from typing import Any +import unittest + +from framework import requirements +from framework.requirements import ( + DEFAULT_CATALOG_DIR, + HISTORY_FILE, + ID_RE, + INDEX_FILE, + LOCK_FILE, + Capability, + CatalogError, + Rule, + Statement, + load_catalog, +) + +PAGE = "docs/specification/shopping/cart/index.md" +# The page as a release before the shopping folder named it. +OLD_PAGE = "docs/specification/cart.md" +TESTABLE = {"testable": True, "testable_reason": "aimed at the business"} +VERSIONS = ["2026-01-11", "2026-04-08", "draft"] + + +def record( + rule_id: str, level: str = "MUST", suite: dict[str, Any] | None = None +) -> dict[str, Any]: + """Return a catalog record with the fields the loader reads.""" + return { + "id": rule_id, + "level": level, + "clause": f"The business **{level}** keep {rule_id}.", + "capabilities": ["dev.ucp.shopping.cart"], + "source": { + "file": PAGE, + "start_line": 12, + "page": "specification/shopping/cart/", + "anchor": "cart-lifecycle", + }, + "suite": TESTABLE if suite is None else suite, + } + + +class SmallCatalogTest(unittest.TestCase): + """Tests against a small catalog in a temporary directory.""" + + def setUp(self): + """Create an empty catalog directory, with nothing cached.""" + super().setUp() + requirements._load.cache_clear() + temporary = tempfile.TemporaryDirectory() + self.addCleanup(temporary.cleanup) + self.catalog_dir = Path(temporary.name) + + def write( + self, + records: list[dict[str, Any]], + lock: dict[str, str], + page: str = "cart/index.json", + ) -> None: + """Write one page of records and a lock of IDs and their statuses.""" + path = self.catalog_dir / "shopping" / page + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps({"requirements": records}), encoding="utf-8") + entries = [{"id": i, "status": status} for i, status in lock.items()] + (self.catalog_dir / LOCK_FILE).write_text( + json.dumps({"lock_version": 1, "entries": entries}), encoding="utf-8" + ) + + def test_looks_up_a_rule(self): + """Test that a rule's fields come from its catalog record.""" + self.write( + [record("REQ-SHOPPING-CART-0001")], {"REQ-SHOPPING-CART-0001": "active"} + ) + self.assertEqual( + load_catalog(self.catalog_dir).rules["REQ-SHOPPING-CART-0001"], + Rule( + id="REQ-SHOPPING-CART-0001", + level="MUST", + clause="The business **MUST** keep REQ-SHOPPING-CART-0001.", + capabilities=("dev.ucp.shopping.cart",), + source_file=PAGE, + line=12, + link="specification/shopping/cart/#cart-lifecycle", + testable=True, + testable_reason="aimed at the business", + is_rule=True, + ), + ) + + def test_level_follows_the_review(self): + """Test that a level corrected by the review replaces the extracted one.""" + suite = {**TESTABLE, "review": {"level": "MUST"}} + self.write( + [record("REQ-SHOPPING-CART-0001", level="MAY", suite=suite)], + {"REQ-SHOPPING-CART-0001": "active"}, + ) + rule = load_catalog(self.catalog_dir).rules["REQ-SHOPPING-CART-0001"] + self.assertEqual(rule.level, "MUST") + + def test_status_of_each_kind_of_id(self): + """Test the four statuses: rule, not a rule, retired and unknown.""" + excluded = {"testable": False, "excluded": True} + self.write( + [ + record("REQ-SHOPPING-CART-0001"), + record("REQ-SHOPPING-CART-0002", suite=excluded), + ], + { + "REQ-SHOPPING-CART-0001": "active", + "REQ-SHOPPING-CART-0002": "active", + "REQ-SHOPPING-CART-0003": "retired", + }, + ) + catalog = load_catalog(self.catalog_dir) + self.assertEqual( + [ + catalog.status(rule_id) + for rule_id in ( + "REQ-SHOPPING-CART-0001", + "REQ-SHOPPING-CART-0002", + "REQ-SHOPPING-CART-0003", + "REQ-SHOPPING-CART-0004", + ) + ], + ["rule", "not a rule", "retired", "unknown"], + ) + + def test_extension_parents(self): + """Test that extensions' parents come from the capability index.""" + self.write( + [record("REQ-SHOPPING-CART-0001")], {"REQ-SHOPPING-CART-0001": "active"} + ) + index = { + "capabilities": [ + { + "name": "dev.ucp.shopping.discount", + "extends": ["dev.ucp.shopping.cart"], + }, + {"name": "dev.ucp.shopping.cart", "extends": []}, + ] + } + (self.catalog_dir / INDEX_FILE).write_text( + json.dumps(index), encoding="utf-8" + ) + catalog = load_catalog(self.catalog_dir) + self.assertEqual( + catalog.with_parents({"dev.ucp.shopping.discount"}), + {"dev.ucp.shopping.discount", "dev.ucp.shopping.cart"}, + ) + self.assertEqual( + catalog.with_parents({"dev.ucp.shopping.order"}), + {"dev.ucp.shopping.order"}, + ) + + def test_capability_index(self): + """Test that capabilities and the spec commit come from the index.""" + self.write( + [record("REQ-SHOPPING-CART-0001")], {"REQ-SHOPPING-CART-0001": "active"} + ) + self.assertEqual(load_catalog(self.catalog_dir).capabilities, ()) + self.assertEqual(load_catalog(self.catalog_dir).spec_commit, "") + requirements._load.cache_clear() + index = { + "suite": {"spec_commit": "f2626c28"}, + "capabilities": [ + {"name": "dev.ucp.shopping.cart", "kind": "capability"}, + { + "name": "dev.ucp.shopping.discount", + "kind": "extension", + "extends": ["dev.ucp.shopping.cart"], + }, + ], + } + (self.catalog_dir / INDEX_FILE).write_text( + json.dumps(index), encoding="utf-8" + ) + catalog = load_catalog(self.catalog_dir) + self.assertEqual( + catalog.capabilities, + ( + Capability("dev.ucp.shopping.cart"), + Capability( + "dev.ucp.shopping.discount", "extension", ("dev.ucp.shopping.cart",) + ), + ), + ) + self.assertEqual(catalog.spec_commit, "f2626c28") + + def test_reads_the_disk_once(self): + """Test that later loads of the same directory reuse the first read.""" + self.write( + [record("REQ-SHOPPING-CART-0001")], {"REQ-SHOPPING-CART-0001": "active"} + ) + first = load_catalog(self.catalog_dir) + (self.catalog_dir / LOCK_FILE).unlink() + self.assertIs(load_catalog(str(self.catalog_dir)), first) + + def test_rejects_a_bad_catalog(self): + """Test that a missing, inconsistent or malformed catalog is an error.""" + cases = { + "missing": lambda: None, + "rule missing from the lock": lambda: self.write( + [record("REQ-SHOPPING-CART-0001")], {} + ), + "active ID missing from the pages": lambda: self.write( + [], {"REQ-SHOPPING-CART-0001": "active"} + ), + "malformed record": lambda: self.write( + [{"id": "REQ-SHOPPING-CART-0001"}], {"REQ-SHOPPING-CART-0001": "active"} + ), + "malformed ID": lambda: self.write( + [record("REQ-SHOPPING-CART")], {"REQ-SHOPPING-CART": "active"} + ), + } + for name, write in cases.items(): + with self.subTest(name), tempfile.TemporaryDirectory() as directory: + self.catalog_dir = Path(directory) + write() + with self.assertRaises(CatalogError): + load_catalog(self.catalog_dir) + + def test_rejects_an_id_on_two_pages(self): + """Test that an ID repeated across pages is an error.""" + self.write([record("REQ-SHOPPING-CART-0001")], {}, page="cart/rest.json") + self.write( + [record("REQ-SHOPPING-CART-0001")], {"REQ-SHOPPING-CART-0001": "active"} + ) + with self.assertRaises(CatalogError): + load_catalog(self.catalog_dir) + + def write_history(self, removed: list[dict[str, Any]]) -> None: + """Write a history of three versions with some removed rules.""" + (self.catalog_dir / HISTORY_FILE).write_text( + json.dumps({"versions": VERSIONS, "removed": removed}), encoding="utf-8" + ) + + def test_reads_the_history(self): + """Test the releases a rule records, and a rule only older ones state.""" + stated = { + **TESTABLE, + "since": "2026-01-11", + "releases": [ + { + "version": "2026-01-11", + "file": OLD_PAGE, + "start_line": 3, + "level": "SHOULD", + "text_digest": "aaaaaaaaaa", + "clause": "The business **SHOULD** keep it.", + }, + { + "version": "2026-04-08", + "file": OLD_PAGE, + "start_line": 9, + "level": "MUST", + "text_digest": "bbbbbbbbbb", + }, + ], + } + self.write( + [record("REQ-SHOPPING-CART-0001", suite=stated)], + {"REQ-SHOPPING-CART-0001": "active", "REQ-SHOPPING-CART-0002": "retired"}, + ) + removed = { + **TESTABLE, + "since": "2026-01-11", + "until": "2026-04-08", + "releases": [ + { + "version": "2026-01-11", + "file": OLD_PAGE, + "start_line": 5, + "level": "MUST", + "text_digest": "cccccccccc", + } + ], + } + self.write_history([record("REQ-SHOPPING-CART-0002", suite=removed)]) + catalog = load_catalog(self.catalog_dir) + self.assertEqual(catalog.versions, tuple(VERSIONS)) + rule = catalog.rules["REQ-SHOPPING-CART-0001"] + self.assertEqual((rule.since, rule.until), ("2026-01-11", None)) + self.assertEqual(rule.versions, tuple(VERSIONS)) + self.assertEqual( + [rule.level_in(v) for v in ("2026-01-11", "2026-01-23", *VERSIONS[1:])], + ["SHOULD", None, "MUST", "MUST"], + ) + self.assertEqual( + rule.statements[0], + Statement( + "2026-01-11", "SHOULD", "The business **SHOULD** keep it.", OLD_PAGE, 3 + ), + ) + # A statement in the rule's own wording takes the record's clause. + self.assertEqual(rule.statements[1].clause, rule.clause) + self.assertEqual(catalog.status("REQ-SHOPPING-CART-0002"), "removed") + gone = catalog.rule("REQ-SHOPPING-CART-0002") + self.assertEqual( + (gone.since, gone.until, gone.versions), + ("2026-01-11", "2026-04-08", ("2026-01-11",)), + ) + self.assertIsNone(gone.level_in("draft")) + self.assertNotIn(gone.id, catalog.rules) + + def test_rejects_a_removed_rule_that_is_not_retired(self): + """Test that a removed rule must have a retired ID in the lock.""" + self.write( + [record("REQ-SHOPPING-CART-0001")], {"REQ-SHOPPING-CART-0001": "active"} + ) + for rule_id in ("REQ-SHOPPING-CART-0001", "REQ-SHOPPING-CART-0002"): + with self.subTest(rule_id): + requirements._load.cache_clear() + self.write_history([record(rule_id)]) + with self.assertRaises(CatalogError): + load_catalog(self.catalog_dir) + + def test_default_catalog_dir_falls_back_to_wheel_copy(self): + """Test that _default_catalog_dir uses the wheel copy outside a repo.""" + wheel = self.catalog_dir / "wheel_catalog" + wheel.mkdir() + missing_repo = self.catalog_dir / "missing_repo_catalog" + self.assertEqual( + requirements._default_catalog_dir(repo_dir=missing_repo, wheel_dir=wheel), + wheel, + ) + self.assertEqual( + requirements._default_catalog_dir( + repo_dir=self.catalog_dir, wheel_dir=wheel + ), + self.catalog_dir, + ) + + +class RepositoryCatalogTest(unittest.TestCase): + """Tests against this repository's catalog.""" + + def setUp(self): + """Load the repository's catalog.""" + super().setUp() + self.catalog = load_catalog() + + def test_matches_its_lock(self): + """Test that every rule fits the ID pattern and has an active lock ID.""" + lock = json.loads((DEFAULT_CATALOG_DIR / LOCK_FILE).read_text("utf-8")) + active = {e["id"] for e in lock["entries"] if e["status"] == "active"} + self.assertEqual(set(self.catalog.rules), active) + self.assertTrue(all(ID_RE.match(rule_id) for rule_id in active)) + + def test_known_rules(self): + """Test what a few stable IDs name, and an extension's parents.""" + self.assertIn( + "dev.ucp.shopping.checkout", + self.catalog.extends["dev.ucp.shopping.fulfillment"], + ) + subtotal = self.catalog.rules["REQ-SHOPPING-CHECKOUT-0133"] + self.assertEqual(subtotal.level, "MUST") + self.assertIn("subtotal", subtotal.clause) + self.assertEqual(subtotal.capabilities, ("dev.ucp.shopping.checkout",)) + self.assertTrue(subtotal.testable) + # Extracted as MAY; the review corrected it to MUST. + self.assertEqual( + self.catalog.rules["REQ-SHOPPING-CATALOG-0046"].level, "MUST" + ) + # The review found this sentence states no requirement. + self.assertEqual( + self.catalog.status("REQ-SHOPPING-CATALOG-0044"), "not a rule" + ) + # Positional IDs from before the lock are no longer valid citations. + self.assertEqual( + self.catalog.status("REQ-CHECKOUT-RENDERING-CONTRACT-05"), "unknown" + ) + + def test_history(self): + """Test the releases that state a few rules, and a removed rule.""" + self.assertEqual( + self.catalog.versions, + ("2026-01-11", "2026-01-23", "2026-04-08", "2026-08-25", "draft"), + ) + # Stated in every release; 2026-01-11 had no list stem for it. + titles = self.catalog.rules["REQ-SHOPPING-FULFILLMENT-0018"] + self.assertEqual(titles.since, "2026-01-11") + self.assertEqual(titles.versions, self.catalog.versions) + # The selection and location identity contract came in 2026-08-25. + self.assertEqual( + self.catalog.rules["REQ-SHOPPING-FULFILLMENT-0015"].since, "2026-08-25" + ) + # Webhook signatures were detached JWTs until RFC 9421 replaced them. + jwt = self.catalog.rule("REQ-SHOPPING-ORDER-0043") + self.assertEqual(self.catalog.status(jwt.id), "removed") + self.assertEqual((jwt.since, jwt.until), ("2026-01-11", "2026-04-08")) + self.assertIn("Request-Signature", jwt.clause) + self.assertTrue(all(rule.until for rule in self.catalog.removed.values())) + + +if __name__ == "__main__": + unittest.main()