diff --git a/.changeset/add-creative-revision-identity.md b/.changeset/add-creative-revision-identity.md
new file mode 100644
index 0000000000..aa86763a0b
--- /dev/null
+++ b/.changeset/add-creative-revision-identity.md
@@ -0,0 +1,7 @@
+---
+"adcontextprotocol": minor
+---
+
+Add buyer-authored immutable creative revision identity across sync, review,
+library readback, and delivery attribution, plus agent-unique served variant
+identity for unambiguous post-flight preview replay.
diff --git a/.changeset/creative-delivery-contracts.md b/.changeset/creative-delivery-contracts.md
new file mode 100644
index 0000000000..2f9bd3165e
--- /dev/null
+++ b/.changeset/creative-delivery-contracts.md
@@ -0,0 +1,5 @@
+---
+"adcontextprotocol": minor
+---
+
+Add explicit creative delivery contracts for inline display tags, atomic paired redirects, and revision-bound creative representation sets. A complete representation set is one immutable buyer revision; deterministic selection identifies one `representation_id` without creating a build or served variant and carries the complete revision digest into the seller-bound manifest. Define exact VAST asset versions versus product and seller acceptance sets, VAST MediaFile delivery/MIME/container/codec/dimension/bitrate/byte requirements, decimal file-size units, and declaration-level technical completeness. Add declared macro dialect, resolver ownership, encoding depth, capability matching, per-token validation results, structured rejection errors, documentation, and conformance vectors for issues #6761–#6764.
diff --git a/docs/contributing/x-entity-annotation.md b/docs/contributing/x-entity-annotation.md
index 9393e0164d..75e7ef075d 100644
--- a/docs/contributing/x-entity-annotation.md
+++ b/docs/contributing/x-entity-annotation.md
@@ -106,7 +106,7 @@ High-level groupings (see the registry for full descriptions). *Categories below
 | Brand & rights | `advertiser_brand`, `rights_holder_brand`, `rights_grant` |
 | Account & party | `account`, `operator` |
 | Media buy | `media_buy`, `package`, `product`, `proposal`, `product_pricing_option`, `spot_airing` |
-| Creative | `creative`, `creative_format` |
+| Creative | `creative`, `creative_revision`, `creative_representation`, `macro_declaration`, `creative_locale_variant`, `creative_format`, `build_variant`, `served_variant` |
 | Data & targeting | `audience`, `audience_evidence`, `audience_evidence_snapshot`, `signal`, `signal_activation_id`, `demographic_interval_id`, `event_source` |
 | Lists & catalogs | `collection_list`, `property_list`, `catalog`, `catalog_generation`, `catalog_item`, `property` |
 | Plans & governance | `media_plan`, `governance_plan`, `governance_registry_policy`, `governance_inline_policy`, `governance_check`, `governance_delivery_statement`, `governance_delivery_observation`, `governance_outcome`, `governance_adjustment`, `governance_adjustment_evidence`, `seller_adjustment`, `content_standards`, `task`, `attestation_credential` |
diff --git a/docs/creative/asset-types.mdx b/docs/creative/asset-types.mdx
index 4745308c90..90b4706ca2 100644
--- a/docs/creative/asset-types.mdx
+++ b/docs/creative/asset-types.mdx
@@ -63,6 +63,8 @@ For payload schemas (the structure of the actual asset data supplied in creative
 - `duration_ms` (when applicable)
 - `format` (declared container type)
 
+File-size limits use decimal, exact units throughout AdCP: `*_kb` means 1 KB = 1,000 bytes, `*_mb` means 1 MB = 1,000,000 bytes, and `*_bytes` is an exact byte count. Do not interpret KB/MB fields as KiB/MiB.
+
 ## Asset Type Schema
 
 The official JSON schema for asset types is available at:
@@ -97,7 +99,7 @@ Video assets represent video files with specific technical requirements.
 - `acceptable_codecs`: Video codecs (h264, h265, vp8, vp9, av1)
 - `acceptable_resolutions`: List of width x height strings
 - `aspect_ratio`: Required aspect ratio (16:9, 9:16, 1:1, etc.)
-- `max_file_size_mb`: Maximum file size in megabytes
+- `max_file_size_mb`: Maximum file size in decimal megabytes (1 MB = 1,000,000 bytes)
 - `min_bitrate_mbps` / `max_bitrate_mbps`: Bitrate range in Mbps
 - `features`: Additional requirements (e.g., ["non-skippable", "sound on"])
 
@@ -123,7 +125,7 @@ Static image assets for banners, logos, and visual content.
 - `min_width` / `min_height`: Minimum dimensions (px; typically used by responsive/sizeless formats)
 - `aspect_ratio`: Required aspect ratio
 - `acceptable_formats`: Image formats (jpg, png, gif, webp, svg)
-- `max_file_size_kb`: Maximum file size in kilobytes
+- `max_file_size_kb`: Maximum file size in decimal kilobytes (1 KB = 1,000 bytes)
 - `transparency`: Whether transparency is required/supported
 - `animation_allowed`: Whether animated GIFs are accepted
 - `notes`: Additional requirements (e.g., "Must be free of text")
@@ -175,6 +177,7 @@ Senders **SHOULD** include `url_type` on every URL asset. The valid values are:
 | Value | Mechanism |
 |---|---|
 | `clickthrough` | User-click destination (landing page or ad-tech redirector) |
+| `ad_request` | Invokes a third-party display creative endpoint at impression time |
 | `tracker_pixel` | Fires HTTP GET, expects 1×1 pixel or 204 response (impression / event / 3P trackers) |
 | `tracker_script` | Loads as a `<script>` tag — measurement SDKs (OMID verification, native event trackers using `method: 2`) |
 
@@ -197,6 +200,8 @@ If `url_type` is **absent**, receivers SHOULD fall back to the format's `url-ass
 | `viewability_tracker` | `tracker_script` — OMID and equivalent verification SDKs **require** a `<script>` tag; firing them as a pixel produces no measurement |
 | `third_party_tracker` | **No safe fallback.** Mechanism is integration-specific (DV/IAS ship both pixel and script forms). Receivers MAY reject or warn. |
 
+Display ad-request URLs also have no role-based fallback. Declare `url_type: "ad_request"` explicitly.
+
 If neither `url_type` nor a format-side `role` is available, receivers MUST NOT silently pick a mechanism — firing a clickthrough URL as a pixel (or vice versa) silently corrupts measurement and breaks the user flow. Receivers SHOULD reject the manifest.
 
 > **VAST/DAAST URLs are not URL assets.** A URL pointing to ad-server XML markup is parsed, not GET-fired. Use `asset_type: "vast"` with `delivery_type: "url"` for VAST tags, and the dedicated tracker types (`vast_tracker` / `daast_tracker`) once those land per [RFC #2915](https://github.com/adcontextprotocol/adcp/issues/2915). A VAST tag declared as `asset_type: "url"` with `url_type: "tracker_pixel"` is non-conformant under these mechanism semantics.
@@ -249,12 +254,12 @@ Audio files for audio ads and podcasts.
 - `duration_seconds`: Expected duration
 - `acceptable_formats`: Audio formats (mp3, m4a, aac, ogg)
 - `min_bitrate_kbps`: Minimum bitrate in kilobits per second
-- `max_file_size_mb`: Maximum file size in megabytes
+- `max_file_size_mb`: Maximum file size in decimal megabytes (1 MB = 1,000,000 bytes)
 - `stereo_required`: Whether stereo audio is required
 
 ### HTML Asset
 
-HTML5 creative assets for rich media formats and third-party display tags.
+Inline HTML content assets. Seller-hosted HTML5 creative bundles use a `zip` asset. Third-party display markup uses the `display_tag` asset below.
 
 ```json
 {
@@ -276,6 +281,21 @@ HTML5 creative assets for rich media formats and third-party display tags.
 - `allowed_features`: Allowed HTML5 features
 - `restricted_features`: Features that must not be used
 
+### Display Tag Asset
+
+An atomic third-party display representation. `delivery_type` is one of `tag_url`, `inline_markup`, or `paired_redirect`. The paired form requires both `ad_request_url` and `clickthrough_url`; they cannot be trafficked or revised independently.
+
+```json
+{
+  "asset_type": "display_tag",
+  "delivery_type": "paired_redirect",
+  "ad_request_url": "https://ads.acme-example.com/ad?slot=42",
+  "clickthrough_url": "https://click.acme-example.com/redirect"
+}
+```
+
+Inline markup also records `markup_type` as `iframe_javascript`, `javascript`, or `standard`. Preserve markup bytes exactly. Do not classify it as `html5`, which means a seller-hosted zip bundle.
+
 ### VAST Asset
 
 VAST (Video Ad Serving Template) tags for third-party video ad serving.
@@ -308,7 +328,7 @@ VAST (Video Ad Serving Template) tags for third-party video ad serving.
 - `delivery_type`: "url" or "inline" (required discriminator)
 - `url`: URL endpoint that returns VAST XML (required when delivery_type is "url")
 - `content`: Inline VAST XML content (required when delivery_type is "inline")
-- `vast_version`: VAST specification version (2.0, 3.0, 4.0, 4.1, 4.2, 4.3)
+- `vast_version`: Exact VAST specification version supplied by this asset (2.0, 3.0, 4.0, 4.1, 4.2, 4.3). Product format options use plural `vast_versions` for their accepted set.
 - `vpaid_enabled`: Whether VPAID (Video Player-Ad Interface Definition) is supported
 - `max_wrapper_depth`: Maximum allowed wrapper/redirect depth
 - `duration_ms`: Expected video duration in milliseconds (if known)
diff --git a/docs/creative/canonical-formats.mdx b/docs/creative/canonical-formats.mdx
index 4373e76fe7..2b6987ca8b 100644
--- a/docs/creative/canonical-formats.mdx
+++ b/docs/creative/canonical-formats.mdx
@@ -328,7 +328,7 @@ Downstream platform authorization is separate from production source. If a forma
 
 When `asset_source` is `buyer_uploaded`, the buyer ships rendered assets and any tracker URLs attached to those assets are buyer-controlled (universal_macros for impression/click; `vast_tracker` / `daast_tracker` assets for decomposed VAST/DAAST trackers). When `asset_source` is any of the seller-rendered values (`seller_pre_rendered_from_brief`, `seller_human_designed`, `agent_synthesized`) or `publisher_host_recorded`, the buyer never sees the rendered artifact directly. Two normative paths apply:
 
-- **Macro-substituted tracking (default).** The seller honors AdCP universal_macros at impression time — `{IMPRESSION_TRACKER}`, `{CLICK_TRACKER}`, etc. — and substitutes buyer-supplied tracker URLs (declared on the manifest's optional `landing_page_url` and the buyer's measurement-vendor pixels declared via `platform_extensions` on the format, filtered by `extensions[uri].extends === "tracking"`) into the rendered creative's serving template. The buyer registers their measurement pixels client-side; the seller calls them at serve time. This is the dominant path for image / video / audio production where serving and tracking are decoupled.
+- **Capability-gated macro-substituted tracking.** Tracker URLs are explicit `pixel_tracker`, `vast_tracker`, or `daast_tracker` assets (or governed tracking extensions); `landing_page_url` remains the navigated destination, not a tracker. Exact macro capabilities declare whether occurrences such as `{IMPRESSION_ID}` and `{CACHEBUSTER}` can be processed, but they do not claim that the product accepts or fires the containing tracker. When the product tracking contract declares the asset type honored, the seller embeds and fires it according to that commitment. Until that contract is present, tracker acceptance and firing are undeclared and buyers MUST NOT infer them from macro compatibility.
 - **Sync-creatives tracker block.** For products where the seller produces a serving artifact that embeds tracker URLs directly (e.g., a generated VAST tag or a stitched companion banner), the seller's `sync_creatives` response SHOULD include a `tracker_block` field listing the impression URL pattern and click URL pattern. Buyers register those with their measurement vendor at sync time. This path covers the generative-DSP pattern where the serving artifact and the tracking shape are produced together.
 
 `vast_tracker` and `daast_tracker` decomposed tracker assets work for both `buyer_uploaded` and seller-rendered sources — when the seller renders, those tracker assets are inputs to the rendered tag, attached to the appropriate VAST/DAAST `<TrackingEvents>` block at production time. When the buyer ships a complete `vast` or `daast` tag, the trackers travel inside the tag.
@@ -536,6 +536,18 @@ Do not use “renderer” for all three roles; it hides the trust and routing bo
 
 Creative declarations describe structural production and acceptance constraints. Price, floor, availability, auction mechanics, and deal eligibility remain product or pricing facts; copying them into format parameters would create multiple authorities for the same commercial term.
 
+### Technical completeness and file-size units
+
+Technical constraints are explicit; canonical prose, examples, common practice, and implementation defaults are never hidden acceptance requirements. For every applicable product, publisher, and placement declaration:
+
+- `technical_requirements_complete: true` means the declaration enumerates every technical creative-acceptance constraint within that layer's authority. An omitted technical field means no constraint at that layer.
+- `technical_requirements_complete: false`, or omission of the assertion, means omitted technical fields are undeclared. Omission means neither “supported” nor “no constraint,” and consumers MUST NOT infer a value.
+- The resolved product/placement contract is complete only when every applicable declaration layer asserts `technical_requirements_complete: true`. A seller making that effective assertion commits that a creative satisfying the published technical contract will not later be rejected for an undisclosed technical constraint.
+
+Completeness is not general creative approval. Policy, legal, security, malware, transport/fetch failure, corrupt bytes, or a material mismatch between declared metadata and inspected content can still cause rejection. For custom formats and platform extensions, a completeness assertion includes the technical constraints in the referenced schema artifacts.
+
+Creative file-size units are decimal and exact throughout AdCP: a field ending in `_kb` uses **1 KB = 1,000 bytes**, a field ending in `_mb` uses **1 MB = 1,000,000 bytes**, and a field ending in `_bytes` is an exact byte count. Implementations MUST NOT substitute binary KiB/MiB units for these fields.
+
 Classification follows the buyer deliverable and who renders it, not the behavioral richness of the placement. For example, a buyer-uploaded MP4 in a docking player is `video_hosted`; an opaque third-party tag that produces the same experience is `display_tag`. Maintainers and catalog encoders can verify these boundaries against the [AdCP 3.2 classification vectors](https://github.com/adcontextprotocol/adcp/blob/main/static/test-vectors/canonical-format-classification.json).
 
 A publisher declares the format contract and enough production semantics for a buyer to know what it must supply: canonical kind, parameter constraints, slots, asset source, composition model, and required connections. It does **not** maintain a vendor list of every creative agent capable of producing that contract. Creative agents self-declare compatibility.
diff --git a/docs/creative/channels/display.mdx b/docs/creative/channels/display.mdx
index 453b547092..3736bdbfc5 100644
--- a/docs/creative/channels/display.mdx
+++ b/docs/creative/channels/display.mdx
@@ -60,22 +60,92 @@ Use min/max width and height for a genuinely responsive envelope. Exact-size, mu
 
 ## HTML5 and third-party tags
 
-`html5` describes a buyer-supplied HTML bundle. `display_tag` describes externally served HTML or JavaScript markup. Keep them separate because validation, hosting, security, and measurement differ.
+`html5` describes a buyer-supplied zip bundle that the seller hosts. `display_tag` describes a third-party-served representation. Keep them separate because validation, hosting, security, and measurement differ. Inline third-party markup is never an `html5` bundle.
+
+Display tags have three delivery types:
+
+| Delivery type | Asset contract |
+|---|---|
+| `tag_url` | One `url` asset with `url_type: "ad_request"`, or a `display_tag` asset with `delivery_type: "tag_url"` |
+| `inline_markup` | One `display_tag` asset with byte-preserved markup and its markup type |
+| `paired_redirect` | One `display_tag` asset containing both `ad_request_url` and `clickthrough_url` |
+
+The existing `tag_url` slot remains the backward-compatible default. A seller accepting inline or paired delivery publishes an explicit option with a `display_tag` slot.
+
+### Inline iframe/JavaScript
 
 ```json
 {
+  "format_option_id": "inline_iframe_javascript_300x250",
   "format_kind": "display_tag",
   "params": {
     "width": 300,
     "height": 250,
+    "supported_delivery_types": ["inline_markup"],
     "slots": [
-      { "asset_group_id": "serving_tag", "asset_type": "html", "required": true },
-      { "asset_group_id": "impression_tracker", "asset_type": "pixel_tracker", "required": false }
+      { "asset_group_id": "serving_tag", "asset_type": "display_tag", "required": true }
     ]
   }
 }
 ```
 
+```json
+{
+  "format_kind": "display_tag",
+  "format_option_ref": {
+    "scope": "product",
+    "format_option_id": "inline_iframe_javascript_300x250"
+  },
+  "assets": {
+    "serving_tag": {
+      "asset_type": "display_tag",
+      "delivery_type": "inline_markup",
+      "markup_type": "iframe_javascript",
+      "markup": "<iframe src=\"https://ads.acme-example.com/render?cb=%%CACHEBUSTER%%\"></iframe>"
+    }
+  }
+}
+```
+
+### Internal Redirect
+
+A two-URL internal redirect is represented portably as `paired_redirect`; the canonical kind remains `display_tag`. The asset is atomic so its two URLs cannot be mixed across rows or revisions.
+
+```json
+{
+  "format_option_id": "acme_internal_redirect_300x250",
+  "format_kind": "display_tag",
+  "params": {
+    "width": 300,
+    "height": 250,
+    "supported_delivery_types": ["paired_redirect"],
+    "slots": [
+      { "asset_group_id": "serving_tag", "asset_type": "display_tag", "required": true }
+    ]
+  }
+}
+```
+
+```json
+{
+  "format_kind": "display_tag",
+  "format_option_ref": {
+    "scope": "product",
+    "format_option_id": "acme_internal_redirect_300x250"
+  },
+  "assets": {
+    "serving_tag": {
+      "asset_type": "display_tag",
+      "delivery_type": "paired_redirect",
+      "ad_request_url": "https://ads.acme-example.com/ad?slot=42&cb=%%CACHEBUSTER%%",
+      "clickthrough_url": "https://click.acme-example.com/redirect?dest=%%DEST_URL_ESC%%"
+    }
+  }
+}
+```
+
+Both fields are required by schema. A half-present pair is invalid. Do not split the pair into independent URL slots.
+
 Buyers discover seller acceptance from `Product.format_options[]`. Creative agents that can build or validate these contracts advertise matching `creative.supported_formats[]` entries.
 
-See [Canonical formats](/docs/creative/canonical-formats), [Creative manifests](/docs/creative/creative-manifests), and [Universal macros](/docs/creative/universal-macros).
+See [Creative representation sets](/docs/creative/representation-sets), [Canonical formats](/docs/creative/canonical-formats), [Creative manifests](/docs/creative/creative-manifests), and [Universal macros](/docs/creative/universal-macros).
diff --git a/docs/creative/channels/video.mdx b/docs/creative/channels/video.mdx
index 45bbfd229b..6237ca5922 100644
--- a/docs/creative/channels/video.mdx
+++ b/docs/creative/channels/video.mdx
@@ -49,20 +49,54 @@ AdCP separates hosted video bytes (`video_hosted`) from VAST delivery (`video_va
 
 ```json
 {
+  "technical_requirements_complete": true,
   "format_kind": "video_vast",
   "params": {
     "duration_ms_range": [15000, 30000],
     "vast_versions": ["3.0", "4.0", "4.1", "4.2"],
+    "media_file_requirements": {
+      "delivery_methods": ["progressive"],
+      "mime_types": ["video/mp4"],
+      "containers": ["mp4"],
+      "codecs": ["avc1.4d401f"],
+      "min_width": 1280,
+      "max_width": 1920,
+      "min_height": 720,
+      "max_height": 1080,
+      "min_bitrate_kbps": 1500,
+      "max_bitrate_kbps": 8000,
+      "max_file_size_bytes": 50000000
+    },
     "slots": [{ "asset_group_id": "vast_tag", "asset_type": "vast", "required": true }]
   }
 }
 ```
 
-Use a `vast` asset with either a URL or inline XML according to the selected declaration. The seller validates wrapper depth, media files, duration, macros, and supported VAST features.
+Use a `vast` asset with either a URL or inline XML according to the selected declaration. The asset's singular `vast_version` is the exact version it supplies. The format option's plural `vast_versions` is the accepted set for that product/player path; seller-wide `execution.creative_specs.vast_versions` is only a ceiling.
+
+Version compatibility is the intersection:
+
+```text
+asset.vast_version
+  ∈ product.format_option.params.vast_versions
+  ∩ seller.execution.creative_specs.vast_versions
+```
+
+For example, a seller may advertise a platform ceiling through VAST 4.2 while one product accepts only VAST 3.0 and 4.0. The product set wins for that product. Never relabel an asset to a newer version merely because the destination supports it.
+
+For ordinary legacy VAST submission, an omitted seller or product version set retains 3.x compatibility and document validation follows the peer's negotiated behavior. Late-bound `CreativeRepresentationSet` resolution is stricter: every VAST candidate declares `vast_version`, and both the selected product option and seller must advertise non-empty plural sets. Absence means compatibility is unproven, not “all versions.” During migration, producers emit either deprecated singular `vast_version` for older consumers or plural `vast_versions` for 3.2 consumers; the two fields are mutually exclusive so they cannot contradict one another.
+
+### MediaFile technical acceptance
+
+`params.media_file_requirements` describes the VAST player's accepted MediaFile renditions: delivery method (`progressive` or `streaming`), MIME type, container, codec, dimensions, bitrate, and maximum exact bytes. For each applicable resolved `<InLine>` linear creative, at least one `<MediaFile>` MUST satisfy every declared requirement. Requirements cannot be assembled across siblings: one progressive MP4 may satisfy the delivery, MIME, and codec constraints while a different streaming WebM satisfies the dimensions, but neither is compatible unless one rendition satisfies the full set. Other incompatible sibling renditions do not reject an otherwise compatible creative.
+
+VAST metadata is the first source of evidence: `delivery`, `type`, `codec`, `width`, `height`, bitrate attributes, and `fileSize` where the applicable VAST version provides them. Fixed `bitrate` must fall within declared bounds; an adaptive `minBitrate`/`maxBitrate` interval must be fully contained by those bounds, not merely overlap them. A receiver MAY safely inspect referenced media bytes and MUST prefer the observed byte count if it conflicts with `fileSize`. It MUST NOT infer a container only from a URI filename extension. When metadata needed for a declared constraint is missing and safe inspection does not establish it, compatibility is unproven; the receiver does not guess.
+
+Omitted MediaFile constraints follow the enclosing declaration's `technical_requirements_complete` value. When every applicable declaration layer asserts completeness, omission means no constraint and the seller cannot later reject a conforming creative for an unpublished delivery-method, MIME, container, codec, dimension, bitrate, or file-size rule. Without that complete assertion, omission means undeclared, not unlimited. `max_file_size_bytes` is always an exact byte count; elsewhere AdCP defines 1 KB as exactly 1,000 bytes and 1 MB as exactly 1,000,000 bytes.
 
 ### VAST Validation
 
-Format-layer validation of `vast` assets is structural: the manifest must satisfy the format's `requirements` (today, `vast_version`), and [`validate_input`](/docs/creative/canonical-formats#validation-flow--validate_input) checks manifest shape only. The VAST document itself is opaque at that level, so a structurally valid manifest can still carry an unplayable tag that fails silently at serve time.
+Format-layer validation of `vast` assets is structural: the manifest must satisfy the format's plural accepted `vast_versions` set, and [`validate_input`](/docs/creative/canonical-formats#validation-flow--validate_input) checks manifest shape and declared compatibility. The VAST document itself is opaque at that level, so a structurally valid manifest can still carry an unplayable tag that fails at serve time.
 
 AdCP defines three validation levels for `vast` assets. Sellers declare the level they perform via `creative_specs.vast_validation` in [`get_adcp_capabilities`](/docs/protocol/get_adcp_capabilities); absent means `structural`. Validation runs at `sync_creatives` time, including `dry_run`. `validate_input` remains manifest-structure-only at every level.
 
@@ -76,17 +110,23 @@ AdCP defines three validation levels for `vast` assets. Sellers declare the leve
 
 - MUST parse the document (inline `content`, or one response fetched from `url`) as XML and reject unparseable documents with `VAST_PARSE_FAILED` (`error.details.reason: "not_xml"`).
 - MUST reject documents whose root element is not `<VAST>` with `VAST_PARSE_FAILED` (`error.details.reason: "no_vast_root"`).
-- MUST reject documents whose `<VAST version>` attribute is missing or does not match the asset's declared `vast_version`, the format's `vast_version` requirement, or the seller's declared `creative_specs.vast_versions`, with `VAST_VERSION_MISMATCH` (`error.details.supported_versions` lists the accepted versions).
+- MUST reject the submitted document when its `<VAST version>` attribute is missing or differs from the asset's singular `vast_version`. The asset declaration describes this submitted URL response or inline document, not every later wrapper hop.
+- MUST reject an asset whose `vast_version` is outside the product `params.vast_versions` and seller `creative_specs.vast_versions` intersection with `VAST_VERSION_MISMATCH`.
+- MUST emit `mismatch_reason: "asset_outside_acceptance"`, `asset_vast_version`, `product_vast_versions`, and `seller_vast_versions` for an acceptance-set failure. Include `format_option_ref` only when the selected option is addressable; a unique id-less option has no reference to invent.
+- MUST emit `mismatch_reason: "document_version_mismatch"`, `asset_vast_version`, raw `observed_document_vast_version`, and `document_role` when an inspected document violates its applicable version rule. For `wrapper` and `terminal_inline` roles, also emit `product_vast_versions` and `seller_vast_versions`, plus `format_option_ref` when the selected option is addressable, because those documents are compared with the acceptance intersection. Use `null` when the required version attribute is missing; preserve unknown/future strings verbatim for diagnosis. `supported_versions` remains a deprecated compatibility field for older 3.x peers.
+<!-- Unreleased 3.2 schema: use /schemas/latest until publication. -->
+- MUST make `VAST_VERSION_MISMATCH` details conform to [`error-details/vast-version-mismatch.json`](https://adcontextprotocol.org/schemas/latest/error-details/vast-version-mismatch.json).
 - SHOULD reject documents containing no `<Ad>` element, and `<InLine>` linear creatives carrying no `<MediaFile>`, with `VAST_PARSE_FAILED` (`error.details.reason: "no_ad"` / `"no_media_file"`).
+- MUST evaluate declared `media_file_requirements` against each applicable `<InLine>` linear creative and reject a creative for which no single `<MediaFile>` satisfies the full declared set. A document-level check evaluates the fetched document; wrapper-level validation evaluates the terminal resolved `<InLine>` document.
 - SHOULD verify that media, tracking, and click URLs use HTTPS.
-- MUST treat unresolved ad-server macros in URLs (`[MACRO]`, `${MACRO}`, `{UNIVERSAL_MACRO}`) as opaque tokens, never as validation failures. Macro correctness and substitution verification are out of scope for this contract.
+- MUST preserve undeclared macro tokens as opaque bytes. When an asset supplies `macro_declarations`, validate each token against the product and seller macro-resolution capability intersection and report per-token results.
 
 **Wrapper-chain validation.** Sellers declaring `wrapper` additionally:
 
 - MUST resolve `<Wrapper>` redirects via `<VASTAdTagURI>` up to the format's declared `max_wrapper_depth` (when present) and reject deeper chains with `VAST_WRAPPER_DEPTH_EXCEEDED` (`error.details.reason: "depth"`).
 - MUST reject chains that revisit a `<VASTAdTagURI>` already seen (a loop) with `VAST_WRAPPER_DEPTH_EXCEEDED` (`error.details.reason: "loop"`).
 - SHOULD apply a per-hop timeout, rejecting with `VAST_WRAPPER_DEPTH_EXCEEDED` (`error.details.reason: "timeout"`), and MUST fetch wrapper hops over HTTPS only.
-- MUST apply document-level checks to the terminal `<InLine>` document and reject with the corresponding document-level code on failure.
+- MUST parse every fetched wrapper and the terminal `<InLine>` document, and require each observed document version to be in the product/seller acceptance intersection. Only the submitted document is compared for equality with the asset's singular declaration; wrapper and terminal documents are not relabeled as the outer asset.
 
 **Preflight, not approval.** A VAST endpoint can return a different document per request (decisioning, rotation, macros). Passing validation at sync time is a preflight of the tag's shape at that moment, not a guarantee about future responses. Sellers MUST NOT treat a passing preflight as approval of all future responses and MAY re-validate during delivery. Sellers fetching `url` assets or wrapper hops SHOULD apply the same server-side request protections (private-address blocking, redirect and size limits) they apply to any other agent-supplied URL fetch.
 
@@ -95,11 +135,11 @@ AdCP defines three validation levels for `vast` assets. Sellers declare the leve
 | Code | Meaning |
 |------|---------|
 | `VAST_PARSE_FAILED` | Document is not well-formed XML, has no `<VAST>` root, no `<Ad>`, or an inline linear creative has no `<MediaFile>` |
-| `VAST_VERSION_MISMATCH` | Document's `<VAST version>` disagrees with the declared `vast_version`, the format requirement, or the seller's supported versions |
+| `VAST_VERSION_MISMATCH` | Document version differs from the asset declaration, or the asset version is outside the product/seller intersection |
 | `VAST_WRAPPER_DEPTH_EXCEEDED` | Wrapper chain exceeds `max_wrapper_depth`, loops, or a hop timed out |
 
 ## Vertical and flexible video
 
 Vertical short video is still `video_hosted`; use width/height or aspect-ratio parameters and, for an exact publisher contract, `{publisher_domain, format_option_id}`. Equal canonical kind alone is not proof that a generic video builder satisfies a publisher's duration, codec, slot, or composition constraints.
 
-See [CTV](/docs/creative/channels/ctv), [Canonical formats](/docs/creative/canonical-formats), and [Creative manifests](/docs/creative/creative-manifests).
+See [Creative representation sets](/docs/creative/representation-sets), [CTV](/docs/creative/channels/ctv), [Canonical formats](/docs/creative/canonical-formats), and [Creative manifests](/docs/creative/creative-manifests).
diff --git a/docs/creative/creative-manifests.mdx b/docs/creative/creative-manifests.mdx
index f7fbe4c4ca..5eb28b7f34 100644
--- a/docs/creative/creative-manifests.mdx
+++ b/docs/creative/creative-manifests.mdx
@@ -125,6 +125,8 @@ Store reusable manifests with `sync_creatives` on agents that advertise `creativ
 
 Approval state is seller-specific. A valid manifest can still enter review, be rejected for policy, or require replacement independently at each destination.
 
+When a manifest was resolved from a set of equivalent trafficking representations, it carries `representation_selection`. That object preserves the durable `creative_id`, complete source `revision_id` plus digest, selected `representation_id`, applied deterministic strategy, and derived-output digest used for review. It is not a rotation or served-variant instruction. See [Creative representation sets](/docs/creative/representation-sets).
+
 ## Deprecated compatibility branch
 
 Older 3.x peers may still send a manifest with a compound named `format_id`. A 3.2 implementation may read it, normalize it to a canonical declaration, and project it back when negotiating with that peer. It must not author new manifests from the legacy shape or mix `format_id` and `format_kind` in one manifest.
@@ -133,5 +135,6 @@ Older 3.x peers may still send a manifest with a compound named `format_id`. A 3
 
 - [Canonical formats](/docs/creative/canonical-formats)
 - [Asset types](/docs/creative/asset-types)
+- [Creative representation sets](/docs/creative/representation-sets)
 - [`build_creative`](/docs/creative/task-reference/build_creative)
 - [`sync_creatives`](/docs/creative/task-reference/sync_creatives)
diff --git a/docs/creative/implementing-creative-agents.mdx b/docs/creative/implementing-creative-agents.mdx
index 9a451281f9..42f3ed4e13 100644
--- a/docs/creative/implementing-creative-agents.mdx
+++ b/docs/creative/implementing-creative-agents.mdx
@@ -300,7 +300,7 @@ Generate a creative manifest from a natural language brief, transform an existin
 - Parse natural language brief or resolve a `creative_id` from your library
 - Generate or source appropriate assets
 - Return valid manifest for the target format
-- Substitute `macro_values` into serving tags when provided
+- Apply `macro_values` under the selected occurrence declaration, or use the documented legacy path when declarations are absent
 - Optionally return preview URL
 
 See [build_creative task reference](/docs/creative/task-reference/build_creative) for complete API specification.
@@ -656,7 +656,7 @@ Platforms represent dynamic content differently. The creative protocol's `variab
 
 ### Macro handling
 
-Platforms use their own macro syntax internally. The `macro_values` parameter in `build_creative` lets the caller pass universal macro values (e.g., `CLICK_URL`) that the creative agent substitutes into the output tag using whatever syntax the platform expects.
+Platforms use their own macro syntax internally. `build_creative.macro_values` carries raw universal values. With occurrence declarations, bind only verified-universal `resolve_value` occurrences performed_by `creative_agent`, after representation selection, and apply the exact declared encoding. The selected `creative.supported_formats[]` route is the authoritative build/preview capability set; the seller-wide ∩ product rule belongs to the later sales execution path. A concrete value does not bypass `translate_to_native`; that operation must emit its target declaration and retain a complete downstream resolution chain. When declarations are absent, use the 3.x legacy translation behavior.
 
 | Universal macro | CM360 equivalent | Flashtalking equivalent |
 |---|---|---|
diff --git a/docs/creative/representation-sets.mdx b/docs/creative/representation-sets.mdx
new file mode 100644
index 0000000000..1031ae935f
--- /dev/null
+++ b/docs/creative/representation-sets.mdx
@@ -0,0 +1,334 @@
+---
+title: Creative representation sets
+description: "Keep equivalent trafficking representations in one immutable creative revision, resolve one against a destination, and retain revision lineage."
+"og:title": "AdCP — Creative Representation Sets"
+---
+
+A logical creative can arrive before its destination is known. It may carry several equivalent trafficking representations—for example, inline display markup plus an Internal Redirect pair, or VAST 2.0, 3.0, and 4.0 URLs. Preserve those alternatives in one `CreativeRepresentationSet` revision, then resolve exactly one into an ordinary seller-bound creative manifest.
+
+This is not creative rotation or A/B testing. Every entry represents the same creative content through a different delivery contract. A representation set is scoped to one canonical format kind: every representation must share the same `format_kind`. Interchangeable packagings for different media types belong in separate sets or separate `sync_creatives` items—seller selection is choosing between delivery contracts for one format, not between media types.
+
+| Identity | Meaning |
+|---|---|
+| `creative_id` | Durable logical creative |
+| `revision_id` | Complete immutable buyer-authored content state |
+| `representation_id` | One equivalent trafficking form inside that revision |
+| `build_variant_id` | One generated or transformed candidate, which may contain different creative content |
+| `locale_variant_id` | One buyer-authored localized asset set |
+| served `variant_id` | One agent-assigned immutable execution observed in delivery reporting |
+
+Selection chooses a `representation_id`. It never chooses or creates one of the variant identities.
+
+## Representation-set object
+
+The set always means “choose exactly one compatible representation.” Arrays inside a manifest asset slot still mean repeatable cardinality; they do not mean representation alternatives.
+
+```json
+{
+  "$schema": "https://adcontextprotocol.org/schemas/latest/core/creative-representation-set.json",
+  "creative_id": "cr_launch_mrec",
+  "revision_id": "rev_2026_08_22_1",
+  "revision_content_digest": "sha256:dfab7f7290bba72f6826ee10186f7618d6b53b3037290f72b094294bceaf6835",
+  "name": "Launch medium rectangle",
+  "representations": [
+    {
+      "representation_id": "source-inline",
+      "format_kind": "display_tag",
+      "assets": {
+        "serving_tag": {
+          "asset_type": "display_tag",
+          "delivery_type": "inline_markup",
+          "markup_type": "iframe_javascript",
+          "markup": "<iframe src=\"https://ads.acme-example.com/render\"></iframe>"
+        }
+      },
+      "source": {
+        "system": "acme_ad_server",
+        "source_representation": "iframe/JavaScript"
+      }
+    },
+    {
+      "representation_id": "source-paired",
+      "format_kind": "display_tag",
+      "assets": {
+        "serving_tag": {
+          "asset_type": "display_tag",
+          "delivery_type": "paired_redirect",
+          "ad_request_url": "https://ads.acme-example.com/ad?slot=42",
+          "clickthrough_url": "https://click.acme-example.com/redirect"
+        }
+      },
+      "source": {
+        "system": "acme_ad_server",
+        "source_representation": "Internal Redirect"
+      }
+    }
+  ]
+}
+```
+
+`creative_id` identifies the durable creative. `revision_id` identifies this complete immutable buyer input state, and each `representation_id` is stable and unique within that revision. Ingestion stores every valid entry without invoking URLs, executing markup, resolving macros, or discarding an unsupported representation.
+
+## Revision identity
+
+The complete representation set is the revision preimage. Producers remove exactly the top-level `$schema`, `creative_id`, `revision_id`, `revision_content_digest`, and `name` properties, serialize everything else with RFC 8785 JCS, and place the lowercase-hex SHA-256 in `revision_content_digest`. `$schema` is transport/schema-location metadata, not creative content. Other unknown fields and representation array order are significant. Producers and resolvers reject duplicate JSON member names, and resolvers recompute the digest before selection.
+
+Changing any representation, its source metadata, the set-level provenance, representation order, or another unknown revision-bearing field requires a new `revision_id` and digest. Renaming the set does not. Selecting, transcoding, macro-binding, or serving one representation does not mint a new revision.
+
+This extends the ordinary [`sync_creatives` revision contract](/docs/creative/task-reference/sync_creatives#creative-revisions): the complete set—not the selected manifest—is bound to `(creative_id, revision_id)`. Reusing that identity with a different digest or canonical content fails with `CREATIVE_REVISION_CONTENT_MISMATCH`. The selected manifest carries the verified digest so a downstream seller can retain the complete-set binding even when it receives only the derived output.
+
+## Seller-bound resolution
+
+Resolution follows this order:
+
+1. Discover the destination's product format option and seller-wide execution capabilities.
+2. Filter candidates by canonical `format_kind` and the selected `format_option_ref`.
+3. Apply the option's asset shape and delivery-mechanism constraints.
+4. For VAST, intersect product and seller version sets.
+5. Evaluate every declared macro against product and seller macro capabilities.
+6. Select exactly one compatible representation.
+
+The buyer may perform these checks locally from seller discovery and submit the selected ordinary manifest. On the wire, `build_creative` representation resolution is intentionally narrower: only the destination sales agent may advertise `creative.representation_resolution.supported: true` and accept a set. A standalone creative agent does not own the product or seller execution ceilings and cannot claim seller compatibility. Silent guessing is never allowed.
+
+The request carries `representation_destination.product_id` plus the exact effective product `format_option`. The destination seller verifies that declaration against its current product, every named placement/publisher narrowing, and its current seller-wide execution ceilings. When `placement_refs` is omitted, the output must satisfy the common effective contract for every placement where it may deliver. `target_capability_id` selects the seller's creative-operation route; it is not a substitute for the inventory contract.
+
+Resolution requires explicit compatibility inputs. In particular, every `video_vast` source representation has an exact asset `vast_version`, while the selected product option and seller advertise non-empty plural `vast_versions`. An absent set is unproven and cannot be treated as accepting every version on this opt-in resolution path.
+
+Equivalence is a buyer assertion, not something the set digest proves. The digest proves that the complete asserted set was not changed; it does not prove that two representations render the same ad or behave identically. A seller MUST apply its ordinary validation and review policy to the exact selected output before approving or serving it. The seller does not need to fetch, execute, or approve every unselected candidate, and it MUST NOT treat acceptance of one candidate as approval of another. Different sellers may select different candidates, but each selected output is separately submitted through `sync_creatives` and reviewed before it can serve. A later selection likewise requires an explicit buyer sync and ordinary re-review, so an unreviewed hidden candidate can never replace the approved execution.
+
+Pass a representation set to the destination seller's `build_creative` route with the product contract and an advertised strategy:
+
+```json
+{
+  "$schema": "https://adcontextprotocol.org/schemas/v3/media-buy/build-creative-request.json",
+  "idempotency_key": "resolve-cr-launch-mrec-rev-1",
+  "creative_representation_set": {
+    "creative_id": "cr_launch_mrec",
+    "revision_id": "rev_2026_08_22_1",
+    "revision_content_digest": "sha256:13358fdf61931ccab0567451eb1a5968786a50d31cee8c384e332b39c3d444d4",
+    "name": "Launch medium rectangle",
+    "representations": [
+      {
+        "representation_id": "source-paired",
+        "format_kind": "display_tag",
+        "assets": {
+          "serving_tag": {
+            "asset_type": "display_tag",
+            "delivery_type": "paired_redirect",
+            "ad_request_url": "https://ads.acme-example.com/ad?slot=42",
+            "clickthrough_url": "https://click.acme-example.com/redirect"
+          }
+        },
+        "source": { "system": "acme_ad_server", "source_representation": "Internal Redirect" }
+      }
+    ]
+  },
+  "representation_destination": {
+    "product_id": "prod_launch_display",
+    "format_option": {
+      "format_option_id": "acme_internal_redirect_300x250",
+      "format_kind": "display_tag",
+      "params": {
+        "supported_delivery_types": ["paired_redirect"]
+      }
+    }
+  },
+  "representation_selection_strategy": "representation_order",
+  "target_capability_id": "display_tag_resolution"
+}
+```
+
+This is a deterministic, single-output mode. It cannot be combined with generation or transformation instructions, transformers, refinement, evaluators, catalog sampling, creative/variant fan-out, brand-generation context, or media-buy/package tag-generation context. `macro_values` is the one permitted operation that may change the derived manifest: selection happens first, then declared build-time macro binding runs without changing the retained source set. Preview fields may request a sidecar render of that selected output, but preview inputs or context never authorize mutation of the manifest or its digest. A pure resolution response never carries `build_variant_id`.
+
+The output is the normal seller-bound manifest. `representation_selection` carries complete-revision lineage through `sync_creatives` and readback:
+
+```json
+{
+  "$schema": "https://adcontextprotocol.org/schemas/v3/core/creative-manifest.json",
+  "format_kind": "display_tag",
+  "format_option_ref": {
+    "scope": "product",
+    "format_option_id": "acme_internal_redirect_300x250"
+  },
+  "representation_selection": {
+    "creative_id": "cr_launch_mrec",
+    "revision_id": "rev_2026_08_22_1",
+    "revision_content_digest": "sha256:13358fdf61931ccab0567451eb1a5968786a50d31cee8c384e332b39c3d444d4",
+    "selected_representation_id": "source-paired",
+    "strategy": "representation_order",
+    "selected_output_digest": "sha256:02735eb8341dc1c2c25b63d20a0a675577407f7500084a67a6ad71ac1bd0e4c3",
+    "resolved_by": "seller"
+  },
+  "assets": {
+    "serving_tag": {
+      "asset_type": "display_tag",
+      "delivery_type": "paired_redirect",
+      "ad_request_url": "https://ads.acme-example.com/ad?slot=42",
+      "clickthrough_url": "https://click.acme-example.com/redirect"
+    }
+  }
+}
+```
+
+The paired redirect stays one asset. A receiver cannot combine its ad-request URL with another row's click-through URL or update either half independently.
+
+`selected_output_digest` is SHA-256 over RFC 8785 JCS of a shared manifest projection. From either the returned `CreativeManifest` or its later `CreativeAsset` sync wrapper, remove exactly top-level `$schema`, `representation_selection`, `creative_id`, `revision_id`, `name`, `tags`, `status`, `weight`, `placement_refs`, `placement_ids`, and `inputs`; include every other field, including unknown delivery fields. The identical projection makes ordinary library wrapping and metadata-only edits digest-neutral while fingerprinting the selected seller-bound output separately from the source revision. A changed selection, macro binding, translation, or transcode may keep the same buyer `revision_id`, but it changes this output fingerprint.
+
+## Sync, review, and readback
+
+On `sync_creatives`, the seller enforces two different invariants:
+
+1. `(creative_id, revision_id, revision_content_digest)` binds immutable buyer source content—the complete representation set, never only the selected entry.
+2. `(selected_representation_id, selected_output_digest)` binds the current seller-bound execution submitted for review.
+
+Changing the source set requires a new buyer `revision_id`. Changing only the selected execution does not mint a buyer revision, but it is an `updated` creative and follows the ordinary re-review lifecycle; approval never transfers silently to different execution bytes. `list_creatives` returns the exact current `representation_selection` while that selected execution remains current. A downstream seller that receives only the selected manifest can verify its output digest and retain the asserted source-set digest, but cannot claim it independently inspected hidden source representations.
+
+Resolution is an explicit buyer-initiated operation, not a continuously
+reevaluated seller policy. After a selected output is accepted by
+`sync_creatives`, later product, placement, VAST, macro, or seller-capability
+changes MUST NOT cause the seller to rerun the strategy, replace
+`representation_selection`, or move the creative into re-review on behalf of
+the buyer. Those changes apply to future resolution requests and assignment
+validation. To replace the current execution, the buyer explicitly calls the
+destination seller's `build_creative` route with the current destination
+contract and then submits the returned manifest through `sync_creatives`.
+`build_creative` alone does not mutate the creative library; the subsequent
+sync is the buyer-visible update that starts ordinary re-review.
+
+If a seller can no longer serve an already accepted execution, it MUST NOT
+silently substitute another representation. It uses the ordinary
+seller/system-initiated creative lifecycle and media-buy impairment surfaces,
+while preserving the exact selection lineage for audit. Buyers reconcile the
+status through `creative.status_changed`, `list_creatives`, and
+`get_media_buys`, then explicitly resolve and sync a replacement when needed.
+An independent seller-initiated re-review may evaluate the same pinned
+execution, but it does not authorize representation re-selection.
+
+Representation resolution is a trafficking-time destination choice, not a
+viewer- or device-time fallback mechanism. `highest_compatible_vast` means the
+highest exact VAST version accepted by the selected product and seller; it does
+not mean the highest version supported by a particular player or device. The
+selected representation remains pinned for every execution until the buyer
+explicitly resolves and syncs a replacement. Device-specific media selection,
+VAST wrapper fallback, and player compatibility remain inside the selected
+VAST document and its `MediaFile` alternatives. Buyers that need distinct
+device contracts must target separate product options or submit separate
+creatives; a representation set never authorizes runtime switching between its
+members.
+
+This version does not combine `representation_selection` with the sync-only
+`localization` mutation. A selected sync item MUST omit `localization`, including
+`null`, and the stored creative MUST NOT already have localization that omission
+would preserve. To migrate an existing localized creative, first submit a
+separate ordinary sync with `localization: null` and no `representation_selection`;
+only after that removal is accepted may the selected output be synced. Locale
+topology and materialized locale assets need their own explicit
+pre-binding projection; treating them as library metadata would allow served
+bytes to change without changing either review fingerprint.
+
+<Warning>
+**Migrating an existing localized creative to representation selection is destructive and non-atomic.** First, submit a `sync_creatives` item with `localization: null` to clear all locale assets — existing localized delivery stops while that sync is under review. Only after the null-sync is accepted may the selected output be synced. There is no atomic path: a re-review window exists between the two steps, and a buyer currently serving localized creatives will experience a delivery gap during migration.
+</Warning>
+
+## Resolution failure
+
+<!-- Unreleased 3.2 schema: use /schemas/latest until publication. -->
+When no candidate works, return `CREATIVE_REPRESENTATION_UNRESOLVED`. `error.details` MUST conform to [`error-details/creative-representation-unresolved.json`](https://adcontextprotocol.org/schemas/latest/error-details/creative-representation-unresolved.json), with exactly one `representation_rejections` entry for every candidate. Unsupported representations remain in the immutable set; failure does not delete or rewrite them.
+
+```json
+{
+  "code": "CREATIVE_REPRESENTATION_UNRESOLVED",
+  "message": "No representation is compatible with the selected format option",
+  "recovery": "correctable",
+  "details": {
+    "representation_rejections": [
+      {
+        "representation_id": "source-vast-2",
+        "code": "vast_version_mismatch",
+        "message": "VAST 2.0 is outside the product and seller compatibility intersection"
+      },
+      {
+        "representation_id": "source-vast-4",
+        "code": "macro_unsupported",
+        "message": "A required player-owned macro is not supported on this execution path"
+      }
+    ]
+  }
+}
+```
+
+## VAST representations
+
+One VAST asset declares one exact `vast_version`; a product option and seller declare accepted sets.
+
+```json
+{
+  "$schema": "https://adcontextprotocol.org/schemas/latest/core/creative-representation-set.json",
+  "creative_id": "cr_launch_video",
+  "revision_id": "rev_7",
+  "revision_content_digest": "sha256:67d087e0a6e84185fc9b28d5854b1f9d90958ac902a3d569422af3ba69951154",
+  "name": "Launch pre-roll",
+  "representations": [
+    {
+      "representation_id": "source-vast-2",
+      "format_kind": "video_vast",
+      "assets": {
+        "vast_tag": {
+          "asset_type": "vast",
+          "delivery_type": "url",
+          "url": "https://video.acme-example.com/vast/2",
+          "vast_version": "2.0"
+        }
+      },
+      "source": { "system": "acme_ad_server", "source_representation": "VAST 2.0 pre-fetch" }
+    },
+    {
+      "representation_id": "source-vast-3",
+      "format_kind": "video_vast",
+      "assets": {
+        "vast_tag": {
+          "asset_type": "vast",
+          "delivery_type": "url",
+          "url": "https://video.acme-example.com/vast/3",
+          "vast_version": "3.0"
+        }
+      },
+      "source": { "system": "acme_ad_server", "source_representation": "VAST 3.0 pre-fetch" }
+    },
+    {
+      "representation_id": "source-vast-4",
+      "format_kind": "video_vast",
+      "assets": {
+        "vast_tag": {
+          "asset_type": "vast",
+          "delivery_type": "url",
+          "url": "https://video.acme-example.com/vast/4",
+          "vast_version": "4.0"
+        }
+      },
+      "source": { "system": "acme_ad_server", "source_representation": "VAST 4.0 pre-fetch" }
+    }
+  ]
+}
+```
+
+If the seller-wide ceiling is `['3.0', '4.0', '4.1', '4.2']` but the selected product accepts only `['3.0', '4.0']`, the compatible candidates are VAST 3.0 and 4.0. `highest_compatible_vast` chooses 4.0 only after that intersection is computed; if multiple compatible candidates declare the same highest exact version, the first in representation array order wins. That strategy is valid only for a `video_vast` destination; using it for another format returns `INVALID_REQUEST` and never silently falls back. `representation_order` always chooses the first compatible entry. Resolution must never relabel the VAST 3.0 asset as 4.0.
+
+## Representation namespaces
+
+`CreativeRepresentationSet.representations[].representation_id` identifies an equivalent trafficking representation within one creative revision. It is distinct from:
+
+- `revision_id`, the complete immutable buyer input state;
+- `build_variant_id`, a generated or transformed output leaf;
+- `locale_variant_id`, a buyer-authored localized asset set;
+- assignment weight or rotation groups; and
+- served `variant_id`, an agent-assigned immutable execution returned by `get_creative_delivery`.
+
+Do not reuse values across these namespaces as a shortcut. Preserve the explicit `representation_selection` join instead.
+
+## Related
+
+- [Display ads](/docs/creative/channels/display)
+- [Video ads](/docs/creative/channels/video)
+- [Universal macros](/docs/creative/universal-macros)
+- [Creative manifests](/docs/creative/creative-manifests)
diff --git a/docs/creative/sales-agent-creative-capabilities.mdx b/docs/creative/sales-agent-creative-capabilities.mdx
index 8db1c5d7f2..285dab3519 100644
--- a/docs/creative/sales-agent-creative-capabilities.mdx
+++ b/docs/creative/sales-agent-creative-capabilities.mdx
@@ -68,6 +68,7 @@ The endpoint may expose both facts, but they remain independent:
 |---|---|
 | `media_buy.inline_creative_management: true` | Package-scoped creative bodies are accepted on create/update media-buy operations |
 | `creative.has_creative_library: true` | The agent exposes reusable library operations such as `sync_creatives` and `list_creatives` |
+| `creative.supports_revisions: true` | The library accepts immutable buyer `revision_id` values and preserves them through sync, review, readback, and delivery. Requires `has_creative_library: true`; does not imply staging or rollback. |
 | `creative.supported_formats[]` | The endpoint exposes canonical build, validation, or preview operations |
 
 An endpoint may support any applicable combination. Inline management does not imply a reusable library; a library does not imply generation.
diff --git a/docs/creative/specification.mdx b/docs/creative/specification.mdx
index 84e26525a4..f836d11cfb 100644
--- a/docs/creative/specification.mdx
+++ b/docs/creative/specification.mdx
@@ -152,7 +152,7 @@ Creative agents MUST validate manifests against format requirements before accep
 ### Native creative localization
 
 Native localization is a library/trafficking capability, distinct from
-`build_creative` fan-out and from served delivery variants. An agent supports
+`build_creative` fan-out and from served execution variants. An agent supports
 it only when `get_adcp_capabilities.creative.localization` is present. This is
 a coarse structural capability: it advertises materialized locale variants,
 RFC 4647 Lookup, and an optional target-variant ceiling, not universal support
@@ -298,6 +298,158 @@ the normal lifecycle webhook. Sellers may reject new or replacement
 localization, but MUST still allow explicit `localization: null` cleanup when it
 does not violate an active assignment.
 
+### Creative revision identity
+
+Buyers may send an optional buyer-assigned `revision_id` on each
+`sync_creatives.creatives[]` item. Agents that advertise
+`creative.supports_revisions: true` commit to the revision guarantees below. A
+`creative_id` identifies the durable logical creative; `revision_id` identifies
+one immutable buyer-authored input state beneath it. Revision support is an
+identity and correlation contract, not a revision-history API: it does not add
+staging, activation, rollback, or enumeration of prior revisions.
+
+Without that capability, a receiver may ignore `revision_id` and the buyer MUST
+NOT rely on immutability, echo, readback, review correlation, or delivery
+attribution. This capability gates reliance, not whether the open 3.2 request
+shape may carry the field.
+
+Revision identity is scoped to `(creative_id, revision_id)`. On first
+acceptance, the seller binds that identity to the creative's canonical revision
+content before any seller transcoding, URL rewriting, normalization, or
+delivery-representation production. Reusing the same identity with the same
+content is idempotently acceptable across requests. Reusing it with different
+content makes that creative item fail with
+`CREATIVE_REVISION_CONTENT_MISMATCH`; its prior library state remains unchanged
+while other items in the best-effort batch may still process. The failed result
+omits `revision_id`; typed error details carry the rejected tuple.
+
+Canonical revision content includes every buyer creative-input field, including
+unknown future content fields, except `creative_id`, `revision_id`, and the
+explicit operational/metadata fields `name`, `tags`, `status`, `weight`,
+`placement_refs`, and `placement_ids`. Format identity, assets,
+`component_assets`, inputs, localization, provenance, rights, and industry
+identifiers are therefore revision-bearing. This fail-closed rule prevents a
+new content field from silently escaping revision identity. The exclusions
+apply only to those exact top-level properties on the sync item; a nested field
+with the same name remains content.
+
+For comparison, first apply the existing sync mutation semantics to the prior
+buyer-authored state. In particular, an allowed omission of `localization`
+means preserve the prior localization topology before comparison; it does not
+make an otherwise identical revision mismatch. `localization: null` is a
+mutation sentinel: consume it by removing localization from the effective state
+before comparison, so a later omission represents the same unlocalized state.
+Then remove those exact top-level excluded fields and encode the effective
+buyer-authored state with RFC 8785 JSON Canonicalization Scheme (JCS). Receivers
+MUST reject duplicate JSON object member names before this comparison. Do not
+materialize schema defaults or perform seller normalization. Object member
+order is therefore irrelevant while array order, unknown fields, and omission
+or explicit `null` remain significant where that field's sync semantics treat
+them as content. URL strings and any supplied content digests are part of the
+input; revision identity does not prove that mutable bytes later served from
+the same URL stayed unchanged. Buyers needing byte-level identity use immutable
+URLs or digest-bound asset forms where available.
+
+A request's
+`idempotency_key` is checked first and protects one request replay window;
+revision identity is then checked across requests. A supporting seller retains
+each revision ID-to-fingerprint binding for the lifetime of the creative and,
+after a soft purge, for the creative tombstone lifetime. It need not retain or
+expose historical payloads. A hard purge removes the binding; reusing the same
+creative ID after its prior lifecycle has been purged begins a new creative
+incarnation.
+
+Accepted sync results echo the exact `revision_id`; `list_creatives` returns
+the creative's current revision; `creative.status_changed` identifies the
+revision reviewed; and every delivered execution derived from a revision
+returns it in `get_creative_delivery.variants[].revision_id`. Seller-generated
+transcodes, normalized tags, or alternate delivery representations remain
+derived from that revision and never mint a buyer revision.
+
+Historical delivery rows identify the revision that actually served. They need
+not equal the revision currently returned by `list_creatives`; a report window
+can span the promotion or replacement of one revision by another.
+
+Submitting a different `revision_id` with content canonically identical to the
+current effective content updates the current revision identity, returns
+`action: "updated"`, and preserves the current review state because no content
+changed. If review is in flight, the seller atomically rebinds that review to
+the new current revision so its eventual result and webhook name the new ID.
+Repeating the current revision and content may return `unchanged`; a
+metadata-only mutation may still return `updated`. Re-submitting a previously
+bound historical revision first must match its retained fingerprint; if its
+content differs from current content, accepting it makes it current and sends
+it through ordinary review. A different revision with different content
+becomes current only if the ordinary update is accepted and must enter review.
+
+When an existing unversioned creative adopts revision identity, canonically
+identical effective content is accepted as `updated`, binds the supplied
+`revision_id`, and preserves review state. If content also changes, the seller
+binds that revision only if the ordinary update is accepted, and the changed
+content enters review.
+
+When a supporting seller receives an update without `revision_id`, omission
+preserves the current revision only if effective canonical content is unchanged
+(for example, a metadata-only update). If accepted effective content changes,
+the seller applies its legacy update rules and clears current revision identity;
+it MUST NOT mint a seller-owned revision. `list_creatives`, subsequent status
+webhooks, and new delivery rows then omit `revision_id` until a buyer supplies
+one. Prior approval does not transfer: an accepted content-bearing unversioned
+update enters the ordinary review lifecycle, subject to the same active-update
+and deadline rules. Historical fingerprint bindings and historical delivery
+attribution remain intact.
+
+Approval never transfers across changed revision content. A revision-aware
+changed-content update uses a new `revision_id` and enters the seller's existing review/update
+lifecycle. Existing active-delivery and deadline rules still decide whether the
+update is accepted, paused, or rejected; revision support does not create a
+staged inactive revision beside the current one.
+
+`revision_id` is correlation identity, not a compare-and-swap token or ordering
+counter. Buyers MUST serialize writes to one creative. Sellers apply ordinary
+last-accepted-update ordering. Except for an identical-content review explicitly
+rebound to a new revision as described above, if a review result for an older revision arrives
+after a newer revision became current, that stale result MUST NOT mutate the
+current revision or its status and MUST NOT emit a status webhook as though it
+applied to the current revision.
+
+When an accepted buyer update moves an approved creative into processing or
+review, that buyer-initiated transition is acknowledged by the
+`sync_creatives` result and does not fire `creative.status_changed`. A later
+seller/system review approval or rejection uses the existing webhook contract.
+This minimal revision contract does not
+keep the prior approved revision serving during review; that behavior belongs
+to the separately deferred staged-activation RFC.
+
+`dry_run: true` evaluates the candidate against existing revision bindings and
+may echo a simulated revision result, but it MUST NOT create or update a
+fingerprint binding or tombstone, change the current revision, or change review
+state.
+
+For ordinary `sync_creatives` items, the effective-state projection above is
+the complete revision preimage. A [`CreativeRepresentationSet`](/docs/creative/representation-sets)
+defines its own deterministic projection over the complete ordered set and
+carries its verified `revision_content_digest` into the selected manifest.
+Comparing only one selected representation is never sufficient to establish
+revision identity. Representation selection does not mint a buyer revision,
+build variant, or served variant.
+
+On a later sync, an item's `creative_id` and `revision_id` must match its
+`representation_selection` lineage. The seller uses the carried complete-set
+digest as the revision fingerprint instead of hashing only the derived selected
+manifest. The actor that emitted the selection must have verified the digest
+against the complete set. A downstream seller receiving only the selected
+output can enforce stable digest reuse but cannot claim independent inspection
+of representations it never received. Separately, the seller verifies and
+retains `(selected_representation_id, selected_output_digest)` as the current
+execution review fingerprint. The output digest uses the same delivery-manifest
+projection before and after library wrapping, excluding library/sync metadata
+such as creative/revision IDs, name, tags, status, weight, placement routing,
+and preview inputs. Sync-time `localization` is forbidden on a selected item in
+this version because it changes served assets and requires an explicit future
+projection. Changing either fingerprint component is an ordinary creative
+update that requires review without minting a new buyer revision.
+
 ### Universal macros
 
 AdCP defines universal macros for cross-platform tracking. Creative agents MUST support these macros in tracking URLs:
@@ -338,6 +490,7 @@ archived ── buyer unarchives ──▶ approved (or pending_review when re-r
 - `processing` → `rejected`: automatic when processing fails (corrupt file, unsupported codec, constraint violation)
 - `pending_review` → `approved`: seller approves after content policy review
 - `pending_review` → `rejected`: seller rejects with `rejection_reason`
+- `approved` → `processing` or `pending_review` (buyer-initiated revision update): accepted only under the seller's ordinary active-delivery and deadline rules; acknowledged on `sync_creatives`, never via `creative.status_changed`. Changed revision content cannot inherit the prior approval.
 - `approved` → `suspended`: seller detects a recoverable dependency/authorization loss, such as `identity_authorization_revoked`, `identity_authorization_expired`, or `source_private` for a `published_post` reference. Sellers MUST surface a corresponding `impairment` on affected active buys.
 - `suspended` → `approved`: seller observes that the dependency is restored and any required re-review passes.
 - `suspended` → `rejected`: seller determines that a previously recoverable dependency/authorization loss cannot be restored for this creative, or that replacement/resubmission is required. Example: a revoked identity/post authorization for a `published_post` reference cannot be reauthorized. Sellers MUST keep affected active buys impaired until the creative is replaced, reassigned, or the package/buy is otherwise remediated.
@@ -465,7 +618,7 @@ Transform, generate, or retrieve creative manifests. Supports three modes:
 - Creative agents SHOULD honor `item_limit` when present, using the lesser of `item_limit` and the format's `max_items`
 - Creative agents MAY use AI/LLM processing for generation tasks
 - When `creative_id` is provided, creative agents MUST resolve the creative from their library
-- When `macro_values` is provided, creative agents SHOULD substitute the specified macros in the output manifest's assets and leave unresolved macros as `{MACRO}` placeholders
+- When `macro_values` is provided and occurrence declarations are present, creative agents bind only verified-universal `resolve_value` occurrences performed_by `creative_agent` and advertised by the selected `creative.supported_formats[]` route, after representation selection, using the declaration's exact encoding. They MUST NOT use a concrete value to bypass `translate_to_native` or its target-resolution capability. Without declarations, the 3.x legacy universal-macro translation behavior applies.
 - Creative agents MUST ignore unrecognized macro keys in `macro_values` — unknown macros are not an error
 - Creative agents SHOULD assign globally unique `creative_id` values; when they cannot guarantee uniqueness, `concept_id` is REQUIRED on `build_creative` requests to disambiguate
 - `build_creative` supports async responses (`status: "working"` with `context_id` polling) for generation and transformation tasks that take significant time. Library retrieval is typically synchronous.
diff --git a/docs/creative/task-reference/build_creative.mdx b/docs/creative/task-reference/build_creative.mdx
index 67c819bbf9..3957290168 100644
--- a/docs/creative/task-reference/build_creative.mdx
+++ b/docs/creative/task-reference/build_creative.mdx
@@ -9,7 +9,8 @@ Transform, generate, or retrieve a creative manifest for a specific format. To r
 
 1. **Generation**: Create a manifest from a brief or seed assets (`message` + `creative_manifest`)
 2. **Transformation**: Adapt an existing manifest to a different format (`creative_manifest` + `target_capability_id`)
-3. **Library retrieval**: Resolve a `creative_id` from the agent's library into a manifest with ad-serving assets
+3. **Representation resolution**: Select one compatible representation from a complete revision-bound `creative_representation_set`
+4. **Library retrieval**: Resolve a `creative_id` from the agent's library into a manifest with ad-serving assets
 
 For generation and transformation, `build_creative` takes a creative manifest as input and produces a creative manifest as output. For library retrieval, provide a `creative_id` (from [`list_creatives`](/docs/creative/task-reference/list_creatives)) and the agent resolves it from its library.
 
@@ -21,6 +22,9 @@ Creative agents advertise canonical outputs through `get_adcp_capabilities.creat
 |-----------|------|----------|-------------|
 | `message` | string | No | Natural language instructions for the creative agent. For generation, this provides creative direction. For transformation, this guides how to adapt the creative. For refinement, this describes the desired changes. |
 | `creative_manifest` | object | No | Canonical creative manifest to transform or use as seed input. It carries `format_kind`, optional `format_option_ref`, and assets. When `creative_id` is provided, the agent resolves the creative from its library and this field is ignored. |
+| `creative_representation_set` | object | No | Complete creative revision containing equivalent trafficking representations. This is a destination-seller-only, deterministic single-output mode. It cannot be combined with generation, transformation, refinement, evaluation, sampling, or fan-out fields. The resolver verifies the full-set `revision_content_digest`, then selects one representation before applying optional `macro_values` to the derived output. The complete set and revision binding do not change. The result carries `representation_selection` and never `build_variant_id`; no compatible candidate returns [`CREATIVE_REPRESENTATION_UNRESOLVED`](/docs/building/verification/compliance-catalog#error-code-creative-representation-unresolved) with one rejection per representation. |
+| `representation_destination` | object | Conditional | Required with `creative_representation_set`. Names the destination seller's `product_id`, exact effective `format_option`, and optional placement scope. The receiving endpoint must own that product and verify the supplied option against its current product and execution capabilities. |
+| `representation_selection_strategy` | string | Conditional | Required with `creative_representation_set`; one strategy advertised by the destination seller's `creative.representation_resolution.strategies`. `representation_order` selects the first compatible entry. `highest_compatible_vast` selects the highest exact compatible VAST version, with source-order tie-breaking. |
 | `creative_id` | string | No | Reference to a creative in the agent's library. The creative agent resolves this to a manifest from its library. Use this instead of `creative_manifest` when retrieving an existing creative for tag generation or format adaptation. |
 | `concept_id` | string | No | Creative concept containing the creative. Used to disambiguate when the same `creative_id` exists in multiple concepts. |
 | `media_buy_id` | string | No | Buyer's media buy reference for tag generation context. When the creative agent is also the ad server (e.g., CM360), this provides the trafficking context needed to generate placement-specific tags. Omit when the platform generates tags at the creative level (Flashtalking, Celtra). This is the buyer's reference — the seller-assigned identifier from [`create_media_buy`](/docs/media-buy/task-reference/create_media_buy). |
@@ -46,7 +50,7 @@ Creative agents advertise canonical outputs through `get_adcp_capabilities.creat
 | `preview_inputs` | array | No | Input sets for preview generation when `include_preview` is true. Each entry has `name` (required), optional `macros`, and optional `context_description`. If omitted, the agent generates a single default preview. Only supported with `target_capability_id` (single-format) — ignored for multi-format requests. |
 | `preview_quality` | string | No | Render quality for inline previews: `"draft"` or `"production"`. Independent of the build `quality` — you can build at draft and preview at production, or vice versa. Only used when `include_preview` is true. |
 | `preview_output_format` | string | No | Output format for preview renders: `"url"` (default) or `"html"`. Only used when `include_preview` is true. |
-| `macro_values` | object | No | Macro values to pre-substitute into the output manifest's assets. Keys are universal macro names (e.g., `CLICK_URL`, `CACHEBUSTER`); values are the literal substitution strings. The creative agent translates universal macros to its platform's native syntax. Macros not provided here remain as `{MACRO}` placeholders for the sales agent to resolve at serve time. |
+| `macro_values` | object | No | Raw values keyed by universal semantic (for example `CLICK_URL` or `CACHEBUSTER`); callers do not pre-encode. With declarations, binding is limited to verified-universal `resolve_value` occurrences performed_by `creative_agent` and advertised by the selected `creative.supported_formats[]` route, using the exact declared encoding. A value does not bypass `translate_to_native` or its target-resolution capability. Without declarations, the legacy universal-macro translation behavior applies. |
 | `account` | [AccountRef](/docs/building/by-layer/L2/accounts-and-agents#account-references) | No | Account reference for pricing and billing. When present, the creative agent applies account-specific pricing from the rate card, records the build against the account, and can enforce quotas. Required by creative agents that charge for their services. |
 | `push_notification_config` | object | No | Operation-scoped webhook configuration for async terminal completion/failure notifications when `build_creative` returns `submitted`. Submitted tasks remain pollable via [`get_task_status`](https://adcontextprotocol.org/schemas/v3/protocol/get-task-status-request.json) whether or not this field is present; agents MUST NOT return `submitted` solely because this field is present. |
 
@@ -565,7 +569,7 @@ You pay for **every produced variant** (`per_unit` × N), not just the ones you
 <Note>
 **Atomicity differs by axis.** Variant production *per format* is atomic — if one variant for a format fails, that format's build fails. Catalog fan-out (`max_creatives`, per item) is **non-atomic**: individual `creatives[]` entries may succeed while others fail. A failed item is returned as a `creatives[]` entry carrying `errors[]` (and no `variants[]`); the batch still succeeds.
 
-**Build-time variants are not delivery variants.** The `build_variant_id` here is a pre-delivery handle for an alternative you produced. It is a different namespace from the served `variant_id` in [`get_creative_delivery`](/docs/creative/task-reference/get_creative_delivery), which identifies a creative *execution that was delivered*. A build-time variant becomes a delivery variant only once you keep and traffic it.
+**Build variants, representations, revisions, and served variants are separate.** `build_variant_id` identifies a candidate produced by this task. `representation_id` identifies one equivalent trafficking form inside a complete `revision_id`. The served `variant_id` in [`get_creative_delivery`](/docs/creative/task-reference/get_creative_delivery) identifies an immutable execution that actually ran. Keeping a build variant may promote it to a durable creative/revision; representation selection and later serving do not reuse its build ID as either of the other identities.
 
 **Resolutions and quality tiers are not variants.** Multiple sizes or quality levels belong on the format axis — pass them as `target_capability_ids` (or `quality`), not as `variant_axis` values. Variants are alternatives *for the same format* (different voice, theme, or best-of-N take).
 </Note>
diff --git a/docs/creative/task-reference/get_creative_delivery.mdx b/docs/creative/task-reference/get_creative_delivery.mdx
index a4e581b1da..9fe806c6ec 100644
--- a/docs/creative/task-reference/get_creative_delivery.mdx
+++ b/docs/creative/task-reference/get_creative_delivery.mdx
@@ -47,7 +47,7 @@ At least one scoping filter (`media_buy_ids` or `creative_ids`) is required.
 | `media_buy_id` | Seller's media buy identifier (present when the request spanned multiple media buys) |
 | `format_kind` | Canonical format of this creative |
 | `totals` | Aggregate delivery metrics across all variants — see [Delivery metrics fields](#delivery-metrics-fields) below |
-| `variant_count` | Total number of variants (may exceed `variants` array length when `max_variants` is used) |
+| `variant_count` | Total number of distinct `variant_id` rows within this creative (may exceed `variants` array length when `max_variants` is used). |
 | `variants` | Array of variant-level delivery data (empty if creative has no variants yet) |
 
 ### Delivery metrics fields
@@ -94,24 +94,59 @@ Fields available on both `creative.totals` and each `variant` entry. Commonly-us
 
 ### Variant Object
 
-Each variant represents a specific execution: a fixed creative (Tier 1), an asset combination the platform selected (Tier 2), or a generated variant (Tier 3). For catalog-driven packages, each catalog item rendered as a distinct ad execution is a variant — the variant's manifest includes the catalog reference with the specific item rendered.
+Each variant row represents a specific execution within one source revision: a fixed creative (Tier 1), an asset combination the platform selected (Tier 2), or a generated variant (Tier 3). For catalog-driven packages, each catalog item rendered as a distinct ad execution is a variant — the variant's manifest includes the catalog reference with the specific item rendered.
 
 | Field | Description |
 |-------|-------------|
-| `variant_id` | Platform-assigned variant identifier |
+| `variant_id` | Agent-assigned served-execution identifier. Existing agents retain uniqueness within agent + creative. An agent advertising `creative.supports_revisions` uses an agent-unique immutable value, which is the unambiguous lookup key when it also supports variant preview. |
+| `revision_id` | Buyer-authored input revision from which this execution was derived. Historical rows may name an older revision than the creative currently returned by [`list_creatives`](/docs/creative/task-reference/list_creatives). |
 | `locale_variant_id` | Buyer-assigned localized variant that supplied the served assets. Required for delivered variants of a localized creative, including default fallback; omitted for unlocalized creatives. |
 | `manifest` | (Optional) The rendered canonical creative manifest—the actual output served, with `format_kind` and resolved assets. |
 | `generation_context` | (Optional, Tier 3) Input signals that triggered generation — e.g., page topic, conversation theme, query category. Platforms provide summarized/anonymized signals, not raw user input. When content context is managed through AdCP content standards, includes an `artifact` reference linking to the specific content artifact. Supports `ext` for vendor-specific context structures. |
 | `ext` | (Optional) Platform-specific data. Social platforms use this for engagement metrics (upvotes, comments, shares) that vary by platform. |
 | Standard metrics | All [Delivery metrics fields](#delivery-metrics-fields) — same shape as `creative.totals` |
 
-`creative_id` and `variant_id` are separate namespaces. The canonical build-to-delivery join is `build_creative.variants[].build_variant_id` → promoted `creative_id` → delivery `creative_id`. `variant_id` remains the platform's served execution variant id.
+`creative_id`, `revision_id`, and `variant_id` are separate namespaces. The
+canonical build-to-delivery join is `build_creative.variants[].build_variant_id`
+→ promoted `creative_id` → delivery `creative_id`. `revision_id` identifies the
+immutable buyer-authored input state beneath that creative; for a seller
+advertising `creative.supports_revisions`, `variant_id` is an agent-unique AdCP
+served-execution identity. Every execution derived from
+a revision carries that revision even when the seller transcodes or chooses
+another equivalent delivery representation.
+
+### Revision attribution
+
+Do not compare every row to the creative's current `list_creatives.revision_id`.
+A reporting window may contain executions from several accepted revisions; each
+row carries the source revision that actually produced that execution.
+
+Every row is revision-homogeneous: all of its metrics come from exactly one
+source revision and, when localized, one locale. For an agent advertising
+`creative.supports_revisions`, `variant_id` is agent-unique and MUST NOT be
+reused for another creative, revision, locale, or rendered manifest; this keeps
+[`preview_creative`](/docs/creative/task-reference/preview_creative) replay by
+`variant_id` unambiguous when variant preview is supported. An adapter
+whose native ad platform reuses an identifier maps each distinct execution to
+a distinct AdCP `variant_id` and may retain the native identifier in `ext`.
+`variant_count` counts distinct `variant_id` values before applying
+`max_variants`. Tier 1 therefore has one row per revision and locale represented
+in the requested period, not necessarily one row for the whole period. A seller
+that cannot partition delivery this way cannot advertise
+`creative.supports_revisions: true`.
+
+For localized delivery, `locale_variant_id` is checked against the source
+revision's accepted localization topology, not only the current
+`list_creatives` topology.
 
 ### Localized delivery attribution
 
 For a localized creative, every returned execution MUST include
-`locale_variant_id` and that value MUST exist in the creative's authoritative
-`list_creatives.localization.variants[]` set. This identifies the assets that
+`locale_variant_id` and that value MUST exist in the accepted localization
+topology of the row's source revision. When that revision is current, the value
+therefore also exists in `list_creatives.localization.variants[]`; historical
+rows are checked against buyer-retained sync state rather than a newer current
+topology. This identifies the assets that
 actually served after strict RFC 4647 Lookup, an explicit locale fallback, or
 the default action and is required for every such path. When the selected
 product format carries `locale_policy`, this value MUST also identify a variant
@@ -125,7 +160,10 @@ Derived metrics like `ctr`, `completion_rate`, `roas`, and `cost_per_click` are
 
 ### Tier 1: Standard Creatives
 
-One creative maps 1:1 to one variant. The variant metrics match the creative totals.
+Within one source revision and locale, a standard creative maps 1:1 to one
+variant. A report spanning revision or locale boundaries contains distinct
+variant rows; a row's metrics match the creative totals only when it is the
+sole row in the reporting period.
 
 ```json
 {
@@ -375,7 +413,7 @@ When a sales agent implements both protocols, both tasks are available on the sa
 When running campaigns across multiple sellers, call `get_creative_delivery` on each agent separately and correlate results:
 
 - **Join key**: Use `creative_id` (buyer-assigned) to correlate the same creative across agents. If you used `concept_id` during upload, filter by concept to group related creatives.
-- **`variant_id` scope**: Variant IDs are unique within an agent and creative, not globally. Two agents may generate variants with the same `variant_id` value. Prefix with the agent URL when building aggregated dashboards.
+- **Variant row scope**: The published default scopes `variant_id` to agent + creative. An agent advertising `creative.supports_revisions` strengthens this to agent-unique and immutable. In either case, use the structured tuple `(agent_url, media_buy_id-or-null, creative_id, variant_id)` as the globally scoped reporting row key; `revision_id` and `locale_variant_id` are immutable attribution fields, not extensions of variant identity.
 - **Timezone handling**: Each agent may report in its own timezone via `reporting_period.timezone`. Normalize to a common timezone before aggregating metrics.
 - **`max_variants` selection**: Agents choose which variants to return when `max_variants` limits the result set. Most agents prioritize by impression volume (most-served first). For representative sampling, make multiple calls with different time ranges rather than relying on a single large `max_variants` value.
 
@@ -389,7 +427,7 @@ When aggregating delivery data from multiple agents into a unified view, follow
 
 3. **Merge by `creative_id`**: Group results by `creative_id` across agents. Sum `totals` (impressions, spend, clicks). Do not average derived metrics like `ctr` — recompute them from the summed components.
 
-4. **Prefix `variant_id`**: Create globally unique variant keys by combining `agent_url + variant_id` (e.g., `https://sales.pinnaclemedia-example.com/var_a1b2c3`). This prevents collisions when two agents assign the same variant ID independently.
+4. **Build a variant-row key**: Serialize the structured tuple `agent_url + media_buy_id-or-null + creative_id + variant_id`. Use actual `null`, not string sentinels, so legitimate IDs cannot collide with absence. Distinct revisions and locales already have distinct agent-assigned `variant_id` values.
 
 5. **Group by `concept_id`**: For campaign-level roll-ups, use `concept_id` to group related creatives across sizes and sellers. Pull the concept-to-creative mapping from [`list_creatives`](/docs/creative/task-reference/list_creatives) on each agent.
 
@@ -418,7 +456,12 @@ for (const [i, result] of results.entries()) {
     for (const v of creative.variants || []) {
       merged[key].variants.push({
         ...v,
-        variant_id: `${agents[i].url}/${v.variant_id}`, // globally unique
+        variant_row_id: JSON.stringify([
+          agents[i].url,
+          creative.media_buy_id ?? result.media_buy_id ?? null,
+          creative.creative_id,
+          v.variant_id,
+        ]),
       });
     }
   }
@@ -437,7 +480,8 @@ Agents that support this task expose `get_creative_delivery` in their tool surfa
 {
   "supported_protocols": ["creative"],
   "creative": {
-    "has_creative_library": true
+    "has_creative_library": true,
+    "supports_revisions": true
   }
 }
 ```
diff --git a/docs/creative/task-reference/list_creatives.mdx b/docs/creative/task-reference/list_creatives.mdx
index eca991ee7f..c8946ca014 100644
--- a/docs/creative/task-reference/list_creatives.mdx
+++ b/docs/creative/task-reference/list_creatives.mdx
@@ -177,6 +177,7 @@ The response provides creative data with optional enrichment:
   "creatives": [
     {
       "creative_id": "ft_88201",
+      "revision_id": "rev_2026_08_23_01",
       "name": "Holiday Sale - Medium Rectangle",
       "format_kind": "image",
       "status": "approved",
@@ -204,11 +205,17 @@ The response provides creative data with optional enrichment:
 }
 ```
 
+When the seller advertises `creative.supports_revisions: true`, `revision_id`
+is the current buyer-authored input revision for that creative. It is exact
+readback of the value accepted by [`sync_creatives`](/docs/creative/task-reference/sync_creatives), not a seller processing or
+transcode version. Older creatives without revision identity may omit it.
+
 ### Per-creative fields
 
 | Field | Type | Description |
 |-------|------|-------------|
 | `creative_id` | string | Unique creative identifier |
+| `revision_id` | string | Current buyer-authored input revision when the current content is revision-bound. Omitted for legacy/unversioned current content. |
 | `name` | string | Human-readable name |
 | `format_kind` | string | Canonical format kind |
 | `format_option_ref` | object | Optional exact publisher/product option reference |
diff --git a/docs/creative/task-reference/preview_creative-advanced.mdx b/docs/creative/task-reference/preview_creative-advanced.mdx
index 944a81efbe..75c53adae8 100644
--- a/docs/creative/task-reference/preview_creative-advanced.mdx
+++ b/docs/creative/task-reference/preview_creative-advanced.mdx
@@ -314,7 +314,7 @@ response = await client.preview_creative(
 
 1. Return consistent HTML from preview URLs
 2. Implement responsive preview pages
-3. Document supported macros via `supported_macros` in formats
+3. For legacy named formats, document the coarse universal set via `supported_macros`; for canonical delivery paths, publish exact `macro_resolution_capabilities` on the selected format option
 4. Clarify preview vs production differences
 5. Consider providing `interactive_url` for testing
 
diff --git a/docs/creative/task-reference/preview_creative.mdx b/docs/creative/task-reference/preview_creative.mdx
index a1570e29f5..a685fa5709 100644
--- a/docs/creative/task-reference/preview_creative.mdx
+++ b/docs/creative/task-reference/preview_creative.mdx
@@ -186,8 +186,8 @@ All modes use a single flat object with `request_type` as the discriminant.
 | `item_limit` | integer | No | Maximum catalog items to render per preview variant. Used in single mode. |
 | `template_id` | string | No | Specific template ID for custom format rendering. Used in single mode. |
 | `requests` | array | Batch | Array of 1-50 preview requests. Each item supplies either a canonical `creative_manifest` or library `creative_id`, and may also carry `target_capability_id`, inputs, quality, output format, item limit, and template ID. |
-| `variant_id` | string | Variant | Platform-assigned variant identifier from [`get_creative_delivery`](/docs/creative/task-reference/get_creative_delivery). |
-| `creative_id` | string | Conditional | Creative-library identifier. Use instead of `creative_manifest` to preview a stored canonical creative; in batch mode it is set per item. It may also provide creative context in variant mode. |
+| `variant_id` | string | Variant | Agent-assigned AdCP served-execution identifier from [`get_creative_delivery`](/docs/creative/task-reference/get_creative_delivery). It is agent-unique for agents advertising `creative.supports_revisions`; callers SHOULD also send `creative_id` for legacy agents whose IDs are scoped to agent + creative. |
+| `creative_id` | string | Conditional | Creative-library identifier. Use instead of `creative_manifest` to preview a stored canonical creative; in batch mode it is set per item. In variant mode it disambiguates the legacy agent + creative identifier scope. |
 | `allow_async` | boolean | No | Opt in to a `status: "submitted"` response for slow rendering. Defaults to `false`; agents MUST stay synchronous or return a terminal error when absent or false. |
 | `push_notification_config` | object | No | Optional terminal completion/failure webhook when `allow_async` is true and the agent returns `submitted`. The task remains pollable without it; this field alone never causes async execution. |
 
diff --git a/docs/creative/task-reference/sync_creatives.mdx b/docs/creative/task-reference/sync_creatives.mdx
index 974bed0899..f308d7c018 100644
--- a/docs/creative/task-reference/sync_creatives.mdx
+++ b/docs/creative/task-reference/sync_creatives.mdx
@@ -147,11 +147,16 @@ Implementations that acknowledge a creative on the synchronous success branch bu
 | `validation_mode` | string     | No       | Validation strictness: `"strict"` (default) or `"lenient"`                                                                                                               |
 | `delete_missing`  | boolean    | No       | When true, creatives not in this sync are archived (default: false). Cannot be combined with `creative_ids`. Cannot delete creatives assigned to active, non-paused packages. |
 
+Every `creatives[]` item in one request MUST have a unique `creative_id`.
+Duplicate IDs make response correlation and write ordering ambiguous, so the
+seller rejects the request rather than applying last-write-wins behavior.
+
 ### Creative object
 
 | Field               | Type                | Required    | Description                                                        |
 | ------------------- | ------------------- | ----------- | ------------------------------------------------------------------ |
 | `creative_id`       | string              | Yes         | Unique identifier for this creative                                |
+| `revision_id`       | string              | No          | Buyer-assigned input-content revision scoped to `creative_id`. May be sent to any 3.2 peer; `creative.supports_revisions: true` gates reliance on its guarantees. |
 | `name`              | string              | Yes         | Human-readable name                                                |
 | `format_kind`       | CanonicalFormatKind | Yes for 3.2 authoring | Portable canonical format path. Pair with `format_option_ref` when exact routing is required. |
 | `format_id`         | FormatId            | Deprecated | Named-format compatibility path for older 3.x peers; mutually exclusive with `format_kind`. |
@@ -164,6 +169,125 @@ New 3.2 integrations use `format_kind` with `format_option_ref` when routing dep
 
 Before uploading, buyers MUST verify each creative manifest against the target product's canonical `format_options[]`. The manifest MUST include every asset slot that the selected format option declares as required, keyed by that slot's `asset_group_id`.
 
+### Creative revisions
+
+Buyers may send `revision_id` to any 3.2 peer. When the agent advertises
+`creative.supports_revisions: true`, buyers may rely on it to correlate one
+immutable input state through sync, review, readback, and delivery. Without the
+capability, the receiver may ignore the field and the buyer cannot rely on
+revision guarantees. A supporting seller echoes it on accepted `created`, `updated`,
+and `unchanged` items and omits it on `failed` and `deleted` items.
+
+The identity is `(creative_id, revision_id)`. Reusing that pair with identical
+canonical revision content is safe even under a new `idempotency_key`. Reusing
+it with changed content fails that creative item with
+[`CREATIVE_REVISION_CONTENT_MISMATCH`](/docs/building/verification/compliance-catalog#error-code-creative-revision-content-mismatch) and leaves its prior state unchanged; other batch items may still process. Mint a new `revision_id` for intentional
+content changes. Metadata-only changes to `name` or `tags`, and assignment
+changes, do not require a new revision. The seller checks `idempotency_key`
+conflicts first, then revision content.
+
+Canonical revision content is RFC 8785 JCS of the effective buyer-authored
+creative state after applying existing sync mutation semantics, then removing
+exactly the top-level `creative_id`, `revision_id`, `name`, `tags`,
+`status`, `weight`, `placement_refs`, and `placement_ids` fields. Sellers do not
+materialize defaults or normalize values before this comparison. Nested fields
+with those names remain content. Duplicate JSON member names are rejected.
+An allowed omitted `localization` preserves the prior topology before
+comparison. `localization: null` removes localization from the effective state
+before comparison, so a later allowed omission represents that same
+unlocalized state. URL identity is the submitted URL string (plus
+any submitted digest), so use immutable or digest-bound asset references when
+byte-level identity matters.
+
+A different revision ID with content identical to the current canonical state
+is accepted as `updated`, becomes current, and preserves the existing review
+state. A seller atomically rebinds any in-flight review to that new
+identical-content ID. A previously bound historical ID must still match its
+retained fingerprint and, when its content differs from current, enters review
+again if accepted. A different revision with changed content enters review. Sellers retain revision
+fingerprint bindings for the creative's lifetime (and any soft-purge tombstone
+window); a hard purge starts a new creative incarnation. Revision IDs are not
+ordering counters—buyers serialize writes, and stale review results for older
+revisions cannot change the current revision or status.
+
+When an existing unversioned creative first adopts revision identity, identical
+effective content is accepted as `updated`, binds the supplied ID, and preserves
+review state. If content also changes, the seller binds the ID only when the
+ordinary update is accepted, and changed content enters review.
+
+An omitted `revision_id` preserves current revision identity only for
+content-equivalent updates. If a supporting seller accepts changed content from
+a legacy unversioned caller, it clears current revision identity and does not
+mint one; later readback, webhooks, and delivery omit the field while historical
+bindings remain retained. Prior approval does not transfer, and an accepted
+content-bearing unversioned update enters the ordinary review lifecycle.
+
+With `dry_run: true`, the seller evaluates existing revision conflicts and may
+echo the simulated revision, but it does not reserve an ID, change bindings or
+tombstones, select a current revision, or alter review state.
+
+When an item carries `representation_selection`, its `creative_id` and
+`revision_id` must equal the selection lineage. The seller binds revision
+identity to `representation_selection.revision_content_digest`, which commits
+to the complete [`CreativeRepresentationSet`](/docs/creative/representation-sets),
+not to the selected manifest bytes alone. The actor that emitted the selection
+must first verify the digest against the complete set. A downstream seller that
+receives only the selected output can enforce stable digest reuse, but cannot
+claim it independently inspected representations it never received.
+
+The seller separately verifies `selected_output_digest` with the same manifest
+projection used by [`build_creative`](/docs/creative/task-reference/build_creative): remove top-level `$schema`,
+`representation_selection`, `creative_id`, `revision_id`, `name`, `tags`,
+`status`, `weight`, `placement_refs`, `placement_ids`, `inputs`, and
+then include every other field. It tracks
+`(selected_representation_id, selected_output_digest)` as the execution review
+fingerprint. A changed selection or changed derived output is an
+`updated` creative and follows ordinary re-review even when the source-set
+`revision_id` and digest remain unchanged. [`list_creatives`](/docs/creative/task-reference/list_creatives) returns the exact
+current selection lineage while that execution remains current.
+
+The seller never performs that replacement implicitly. Once accepted, the
+selection is pinned even if later product or seller capabilities would choose
+a different representation. Capability drift affects future resolution and
+assignment checks; it does not mutate the library creative or start re-review.
+The buyer must explicitly resolve again with `build_creative` and submit the
+new selected output here. This sync response acknowledges the update and starts
+ordinary re-review. If the seller can no longer serve the pinned execution, it
+uses the ordinary seller/system status-change and media-buy impairment
+surfaces without substituting another representation.
+
+A sync item carrying `representation_selection` MUST omit `localization`,
+including `null`, in this version, and the stored creative must not already
+have localization that ordinary omission would preserve. Remove an existing
+topology first with a separate accepted sync carrying `localization: null` and
+no `representation_selection`, then submit the selected output. Localization
+replaces materialized serving assets and cannot be treated as digest-neutral library metadata. A future
+localized representation-set contract must define locale topology inside the
+pre-binding revision and selected-output projections explicitly.
+
+Revision support does not add staged activation or revision history. A newly
+accepted content revision follows the ordinary creative update and review
+lifecycle, and prior approval does not transfer to changed content. The
+buyer-initiated transition is acknowledged on this response rather than a
+`creative.status_changed` webhook; subsequent seller/system review transitions
+use the ordinary webhook. The prior revision is not kept serving during review.
+
+A revised creative under re-review is ineligible for delivery like any other
+`pending_review` creative until it re-reaches `approved`. Other creatives
+assigned to the same package are unaffected and continue under the seller's
+ordinary selection behavior. A package that relies only on the revised creative
+therefore has a serving gap by default; buyers that need zero-gap replacement
+can sync the candidate under a new `creative_id` and change assignments after
+approval. Staged activation of a replacement under the same identity is outside
+this revision contract.
+
+Creatives produced through [`build_creative`](/docs/creative/task-reference/build_creative)
+become buyer-authored revision state when the buyer accepts and syncs the
+returned manifest, choosing the `creative_id` and minting (or omitting) the
+`revision_id`. Seller-side drafts before that sync boundary are outside AdCP's
+revision history; seller transformation and transcoding after the boundary do
+not mint buyer revision IDs.
+
 ### Native localization
 
 Discover support before writing. The agent's
@@ -400,6 +524,7 @@ The final per-creative `creatives` array lands on the task completion artifact,
 
 - All request fields
 - `platform_id` - Platform's internal ID (when `action` is not `failed`)
+- `revision_id` - Exact request revision on accepted `created`, `updated`, or `unchanged` items when supplied. Omitted on `failed` and `deleted`.
 - `action` - Lifecycle operation performed by this sync: `created`, `updated`, `unchanged`, `failed`, `deleted`
 - `status` - **Advisory** review-lifecycle state ([`CreativeStatus`](https://adcontextprotocol.org/schemas/v3/enums/creative-status.json)): `processing`, `pending_review`, `approved`, `suspended`, `rejected`, `archived`. A UI hint and polling-scheduling signal — **not** a spend-authorization gate. Orthogonal to `action` — `action` describes what the sync did, `status` describes where the creative is in the review lifecycle. Values come from `CreativeStatus` only, never from `CreativeAction` (never put `created`/`updated`/`failed` in `status`). Sellers with async review return `processing` or `pending_review`; sellers with synchronous review MAY return a terminal value (`approved`/`rejected`) or `suspended` when a recoverable dependency/authorization gate prevents serving. **Buyers MUST NOT gate downstream spend or package activation on `status: approved` from this response** — reconcile via [`list_creatives`](/docs/creative/task-reference/list_creatives) or a signed review webhook before committing spend. Authoritative state is always via `list_creatives`. **MUST be omitted** when `action` is `failed` or `deleted` — failed items have no meaningful review state (see `errors`); deleted items are gone from the library. The schema enforces the omission rule via a conditional constraint.
 - `localization` - Exact materialized source/target locale state. Required with top-level `status` on every accepted localized item, omitted on failed/deleted/unlocalized items. The top-level status is the single creative-wide review state.
diff --git a/docs/creative/universal-macros.mdx b/docs/creative/universal-macros.mdx
index 963b2dbbdb..07b30728ec 100644
--- a/docs/creative/universal-macros.mdx
+++ b/docs/creative/universal-macros.mdx
@@ -7,6 +7,8 @@ description: "Universal macros in AdCP insert dynamic tracking data into creativ
 
 Universal macros enable buyers to include dynamic tracking data in their creatives without needing to know each publisher's ad server implementation details. Macros are placeholders that get replaced with actual values at impression time.
 
+Universal semantics and source syntax are separate. `{CACHEBUSTER}`, `[CACHEBUSTING]`, and a vendor token can share a cache-busting meaning while requiring different resolvers and encoding. Never translate from spelling alone.
+
 ## Overview
 
 When you provide creative assets to AdCP, you can include universal macro placeholders in:
@@ -33,6 +35,199 @@ https://track.brand.com/imp?
   cb=87654321
 ```
 
+## Declared source-token contracts
+
+Delivery assets may attach `macro_declarations[]`. Each entry describes one occurrence of one exact source token. Company names are not dialect values: `dialect` is the small family enum `adcp | iab_vast | iab_daast | vendor | unknown`; IAB and vendor entries add an authority-controlled `dialect_namespace` and immutable `dialect_revision`.
+
+The namespace identifies the registry, while the revision pins the exact mapping bytes. For the live IAB VAST macro registry, use its canonical published registry URL as the namespace and an immutable source commit or content digest as the revision; a VAST document version is not a macro-registry revision because the registry evolves independently. Compatibility requires exact namespace and revision equality—implementations never treat a moving branch name or “latest” content as the revision.
+
+Translation and value resolution are different operations. `translate_to_native` changes an AdCP token into a declared downstream token without inserting a runtime value. The translated asset replaces the old declaration with the supplied `translation_target`. `resolve_value` inserts a concrete value using the exact encoding profile. `preserve` performs no mutation.
+
+The first contract permits one translation hop followed by value resolution; `translation_target.next_operation` is therefore fixed to `resolve_value`, which prevents cycles and unbounded chains. On the sales execution path, a translation is compatible only when both seller-wide and selected-product sets contain the source translation tuple and an exact target resolution tuple. On `build_creative`, `preview_creative`, and `validate_input`, the selected `creative.supported_formats[]` route is the authoritative capability set and build-time operations use `performed_by: creative_agent`; no seller authority is borrowed. The emitted target declaration keeps the source `declaration_id`, `location`, `required`, and `unavailable_behavior`, and replaces token, dialect identity, operation, actor, and encoding from `translation_target`.
+
+```json
+{
+  "$schema": "https://adcontextprotocol.org/schemas/latest/core/assets/display-tag-asset.json",
+  "asset_type": "display_tag",
+  "delivery_type": "tag_url",
+  "url": "https://ads.acme-example.com/render?cb=[CACHEBUSTING]&click=%%ACME_CLICK_ESC2%%&gdpr={GDPR}&consent={GDPR_CONSENT}&gpp={GPP_STRING}&player=[PLAYERSTATE]&unknown=%%VENDOR_TOKEN%%",
+  "macro_declarations": [
+    {
+      "declaration_id": "cachebuster",
+      "token": "[CACHEBUSTING]",
+      "dialect": "iab_vast",
+      "dialect_namespace": "https://interactiveadvertisingbureau.github.io/vast/vast4macros/vast4-macros-latest.html",
+      "dialect_revision": "git:e0858cd714474bf17ef61065097456d7643ff838",
+      "dialect_semantic": "CACHEBUSTING",
+      "mapping_status": "verified_universal",
+      "universal_semantic": "CACHEBUSTER",
+      "operation": "resolve_value",
+      "performed_by": "request_executor",
+      "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+      "encoding": { "kind": "iab_vast_uri", "depth": 1 },
+      "required": true,
+      "unavailable_behavior": "reject"
+    },
+    {
+      "declaration_id": "nested-click",
+      "token": "%%ACME_CLICK_ESC2%%",
+      "dialect": "vendor",
+      "dialect_namespace": "https://macros.acme-example.com/registry",
+      "dialect_revision": "mapping-v1",
+      "dialect_semantic": "CLICK_ESC2",
+      "mapping_status": "verified_universal",
+      "universal_semantic": "CLICK_URL",
+      "operation": "resolve_value",
+      "performed_by": "seller",
+      "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+      "encoding": { "kind": "rfc3986", "depth": 2 },
+      "required": true,
+      "unavailable_behavior": "reject"
+    },
+    {
+      "declaration_id": "gdpr-applies",
+      "token": "{GDPR}",
+      "dialect": "adcp",
+      "dialect_semantic": "GDPR",
+      "mapping_status": "verified_universal",
+      "universal_semantic": "GDPR",
+      "operation": "resolve_value",
+      "performed_by": "seller",
+      "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+      "encoding": { "kind": "none", "depth": 0 },
+      "required": true,
+      "unavailable_behavior": "reject"
+    },
+    {
+      "declaration_id": "tcf-consent",
+      "token": "{GDPR_CONSENT}",
+      "dialect": "adcp",
+      "dialect_semantic": "GDPR_CONSENT",
+      "mapping_status": "verified_universal",
+      "universal_semantic": "GDPR_CONSENT",
+      "operation": "resolve_value",
+      "performed_by": "seller",
+      "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+      "encoding": { "kind": "rfc3986", "depth": 1 },
+      "required": false,
+      "unavailable_behavior": "omit_parameter"
+    },
+    {
+      "declaration_id": "gpp-string",
+      "token": "{GPP_STRING}",
+      "dialect": "adcp",
+      "dialect_semantic": "GPP_STRING",
+      "mapping_status": "verified_universal",
+      "universal_semantic": "GPP_STRING",
+      "operation": "resolve_value",
+      "performed_by": "seller",
+      "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+      "encoding": { "kind": "rfc3986", "depth": 1 },
+      "required": false,
+      "unavailable_behavior": "omit_parameter"
+    },
+    {
+      "declaration_id": "player-state",
+      "token": "[PLAYERSTATE]",
+      "dialect": "iab_vast",
+      "dialect_namespace": "https://interactiveadvertisingbureau.github.io/vast/vast4macros/vast4-macros-latest.html",
+      "dialect_revision": "git:e0858cd714474bf17ef61065097456d7643ff838",
+      "dialect_semantic": "PLAYERSTATE",
+      "mapping_status": "dialect_defined",
+      "operation": "resolve_value",
+      "performed_by": "request_executor",
+      "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+      "encoding": { "kind": "iab_vast_uri", "depth": 1 },
+      "required": false,
+      "unavailable_behavior": "dialect_sentinel"
+    },
+    {
+      "declaration_id": "unidentified-token",
+      "token": "%%VENDOR_TOKEN%%",
+      "dialect": "unknown",
+      "dialect_semantic": "unresolved",
+      "mapping_status": "unresolved",
+      "operation": "preserve",
+      "location": { "field": "url", "occurrence": 0, "context": "opaque" },
+      "encoding": { "kind": "none", "depth": 0 },
+      "required": false,
+      "unavailable_behavior": "preserve"
+    }
+  ]
+}
+```
+
+The click redirect's depth of two is part of the contract, not an implementation hint. `rfc3986` encodes UTF-8 bytes outside the RFC 3986 unreserved set once per depth. `iab_vast_uri` follows the cited VAST registry's one-pass rules, including array serialization and unavailable-value sentinels. A resolver never invents consent strings, device identifiers, vendor IDs, impression IDs, or fallback values.
+
+`dialect_semantic` is the cited namespace's exact meaning. `universal_semantic` appears only for a verified mapping into AdCP's closed universal vocabulary. A dialect-defined token such as `[PLAYERSTATE]` remains specific without being mislabeled as a generic vendor semantic. Unknown tokens are schema-constrained to optional, zero-encoding preservation.
+
+Every `declaration_id` is unique within its asset. Each declared token must exist at the named zero-based occurrence, and every claimed occurrence must have exactly one declaration. This occurrence-level rule prevents one encoding contract from being applied indiscriminately to the same spelling in a URL, path, or opaque markup context.
+
+## Capability matching and validation
+
+Sellers publish a seller-wide ceiling in `execution.creative_specs.macro_resolution_capabilities`. The selected product format option publishes the binding set in its top-level `macro_resolution_capabilities` field, alongside `format_kind` and `params`. Each entry is one exact semantic/operation/actor contract; it does not create a cross-product from a semantic list and maximum depth. Capability metadata is deliberately outside canonical `params`: it describes who can process a selected format option, not the creative shape itself.
+
+Standalone creative agents use a separate route rule: the selected `creative.supported_formats[]` entry's `format.macro_resolution_capabilities` is authoritative for build, preview, and validation, and its build-time entries name `performed_by: creative_agent`. The sales seller∩product intersection is evaluated later if the resulting manifest enters a seller execution path.
+
+```json
+{
+  "format_kind": "video_vast",
+  "macro_resolution_capabilities": [
+    {
+      "dialect": "adcp",
+      "dialect_semantic": "GDPR_CONSENT",
+      "mapping_status": "verified_universal",
+      "universal_semantic": "GDPR_CONSENT",
+      "operation": "resolve_value",
+      "performed_by": "seller",
+      "supported_contexts": ["url_query_value"],
+      "supported_encodings": [{ "kind": "rfc3986", "depth": 1 }]
+    },
+    {
+      "dialect": "iab_vast",
+      "dialect_namespace": "https://interactiveadvertisingbureau.github.io/vast/vast4macros/vast4-macros-latest.html",
+      "dialect_revision": "git:e0858cd714474bf17ef61065097456d7643ff838",
+      "dialect_semantic": "PLAYERSTATE",
+      "mapping_status": "dialect_defined",
+      "operation": "resolve_value",
+      "performed_by": "request_executor",
+      "supported_contexts": ["url_query_value"],
+      "supported_encodings": [{ "kind": "iab_vast_uri", "depth": 1 }]
+    }
+  ],
+  "params": {
+    "vast_versions": ["3.0", "4.0"]
+  }
+}
+```
+
+Compatibility matches dialect family, namespace, revision, exact dialect semantic, verified universal mapping when present, operation, actor, occurrence context, and exact encoding. Local capabilities are required only when the local path performs the operation. A token owned by an advertised downstream request executor is classified `resolvable`; its source bytes remain unchanged until that actor runs. `preserved_for_downstream` is reserved for an intentional `preserve` operation with no exact resolver claim.
+
+`request_executor` is functional rather than organizational: it is the component actually issuing the governed VAST/DAAST or tracking request, whether that is a client player, publisher player, SSAI service, or another execution component.
+
+`validate_input` and `sync_creatives` return one path-addressable `macro_resolution_results[]` entry per declaration:
+
+- `resolvable` — the selected path advertises the exact operation; no serve-time result is implied;
+- `preserved_for_downstream` — the declaration intentionally requests byte-preserved handoff and makes no exact resolver claim;
+- `unsupported` — no compatible resolver/capability exists; or
+- `ambiguous` — the declaration does not establish one safe meaning.
+
+<!-- Unreleased 3.2 schema: use /schemas/latest until publication. -->
+A required `unsupported` or `ambiguous` token fails with `MACRO_RESOLUTION_FAILED`. Its `error.details` MUST conform to [`error-details/macro-resolution-failed.json`](https://adcontextprotocol.org/schemas/latest/error-details/macro-resolution-failed.json). Results include the asset pointer, declaration ID, requested encoding, structured reason, and advertised encoding candidates.
+
+## Relationship to existing macro surfaces
+
+The occurrence contract extends the existing lifecycle; it does not replace it:
+
+1. `format.supported_macros` is the legacy named-format projection of accepted AdCP universal semantics. It does not prove native-dialect execution, ownership, or encoding.
+2. `build_creative.macro_values` and preview macro values supply concrete raw values. With declarations, a value binds only a verified-universal `resolve_value` occurrence performed_by `creative_agent` and advertised by the selected creative route, after representation selection, using its exact encoding. It never bypasses `translate_to_native` or the target capability chain. Without declarations, the legacy behavior remains unchanged for 3.x compatibility.
+3. `translateUniversalMacros` has a raw `native` arm and a one-pass encoded `value` arm. With declarations, a native mapping performs `translate_to_native`, emits the exact target token unchanged, and replaces the source declaration with its `translation_target`; a concrete mapping follows the declaration's encoding. Existing unmapped/frozen-consent diagnostics remain mandatory.
+4. Dropping an unmapped query parameter is behavior of that explicitly invoked legacy helper. It is not the ingest or transport default. Assets without declarations retain opaque-token transport and are not proven compatible.
+5. Webhook `supported_macros` describes runtime webhook arguments, while preview/build `macros` are sample values. Neither is a creative-token resolution capability.
+6. The proposed #6207 product tracking contract remains responsible for whether a seller honors and fires buyer tracker asset types. When it lands, its detailed substitution claims reuse these exact macro capability entries; it does not redefine dialect, ownership, or encoding.
+
+Catalog-item universal semantics retain their existing stricter rule: UTF-8/NFC values receive exactly one RFC 3986 unreserved-set encoding pass. A declaration cannot weaken or add nesting to that governed catalog substitution profile; nested redirect encoding applies only to a separately cited click-redirect mapping.
+
 ## Available Macros by Format
 
 Different creative contracts support different macros. Read macro support from the selected product, publisher, or creative-capability canonical declaration.
@@ -267,7 +462,7 @@ The following rules apply to all catalog-item macros listed above — both the I
 - **Nested macro expansion is prohibited.** A catalog-item value that itself contains text matching AdCP's `{MACRO_NAME}` syntax MUST NOT be re-expanded. Sales agents perform AdCP macro substitution in one pass: source placeholders are replaced with literal values, and those literal values are not re-scanned. A `{JOB_ID}` value of `vacancy-{DEVICE_ID}-42` produces the literal string `vacancy-%7BDEVICE_ID%7D-42` (after percent-encoding of the braces) in the emitted URL, not a second-round expansion. This rule binds AdCP's `{...}` syntax only; catalog-item values containing downstream ad-server macro syntaxes (`%%...%%`, `${...}`, `[...]`, `{{...}}`) remain the sales agent's responsibility to neutralize when targeting an ad server that would interpret them — percent-encoding per the rule above typically suffices, since `%`, `$`, `[`, `]`, and `{` all land outside the `unreserved` set.
 - **Scope is URL contexts only.** These rules apply when a catalog-item macro is substituted into a URL context. When a catalog-item macro is substituted into an HTML-attribute context (for example, a banner template's `href` or `data-*` attribute rendered server-side), percent-encoding per this section does not by itself prevent attribute-context breakout; the renderer MUST additionally apply HTML-attribute escaping — the two encodings are layered, not alternatives, because the value must survive both the URL parser and the HTML attribute parser. AdCP's normative contract bounds to the URL-context case; publisher-side HTML-attribute handling is out of scope for this spec.
 
-Non-catalog macros (`{MEDIA_BUY_ID}`, `{PACKAGE_ID}`, `{CREATIVE_ID}`, `{GEO}`, `{COUNTRY}`, `{DEVICE_TYPE}`, etc.) are populated from publisher- or ad-server-mediated state, not from buyer-supplied feed data. Their encoding contract is governed by the ad-server integration (OpenRTB, VAST), which percent-encodes by convention. Some macros in this class derive from attacker-spoofable inputs (`{USER_AGENT}`, `{REFERRER}`, `{PAGE_URL}`, `{DOMAIN}`, `{APP_BUNDLE}` come from request headers or page metadata); the OpenRTB / ad-server encoding convention is the control today. This spec's normative MUST deliberately scopes to the buyer-controlled catalog-item class — a narrower, verifiable contract than a universal canonicalization rule.
+Non-catalog macros (`{MEDIA_BUY_ID}`, `{PACKAGE_ID}`, `{CREATIVE_ID}`, `{COUNTRY}`, `{DEVICE_TYPE}`, etc.) are populated from publisher- or ad-server-mediated state, not from buyer-supplied feed data. Their encoding contract is governed by the ad-server integration (OpenRTB, VAST), which percent-encodes by convention. Some macros in this class derive from attacker-spoofable inputs (`{USER_AGENT}`, `{REFERRER}`, `{PAGE_URL}`, `{DOMAIN}`, `{APP_BUNDLE}` come from request headers or page metadata); the OpenRTB / ad-server encoding convention is the control today. This spec's normative MUST deliberately scopes to the buyer-controlled catalog-item class — a narrower, verifiable contract than a universal canonicalization rule.
 
 **Conformance fixture.** Reference test vectors pinning the encoding behavior — reserved-character breakout, nested-expansion literal preservation, CRLF injection, non-ASCII — are versioned at [`static/compliance/source/test-vectors/catalog-macro-substitution.json`](https://github.com/adcontextprotocol/adcp/blob/main/static/compliance/source/test-vectors/catalog-macro-substitution.json). Sales agents SHOULD validate their substitution code against these vectors before shipping.
 
@@ -302,7 +497,7 @@ Non-catalog macros (`{MEDIA_BUY_ID}`, `{PACKAGE_ID}`, `{CREATIVE_ID}`, `{GEO}`,
 - Mix AdCP macros (`{MEDIA_BUY_ID}`) with VAST macros (`[CACHEBUSTING]`)
 - AdCP macros use `{CURLY_BRACES}`
 - VAST macros use `[SQUARE_BRACKETS]`
-- Both work together seamlessly
+- Declare dialect, owner, and encoding when compatibility must be proven before trafficking
 
 ### Display Creative with Tracking
 
@@ -375,6 +570,8 @@ Non-catalog macros (`{MEDIA_BUY_ID}`, `{PACKAGE_ID}`, `{CREATIVE_ID}`, `{GEO}`,
 
 Not all macros are available in all inventory types. Check format specifications to see which macros are supported.
 
+This matrix is informative implementation guidance, not a capability claim. The selected product format option's exact `macro_resolution_capabilities` entry is authoritative for dialect identity, operation, actor, context, and encoding; legacy named formats may expose only the coarser `supported_macros` projection.
+
 **Important**: The columns below represent format types (Display, Video, etc.) which can run in different environments (app vs web). For example:
 - Display ads in mobile apps have `DEVICE_ID` (✅*), but display ads on web do not
 - The ✅* notation means "available in-app contexts only"
@@ -457,38 +654,26 @@ Inspect the selected canonical declaration to see which macros it supports:
 {
   "format_option_id": "video_30s_vast",
   "format_kind": "video_vast",
-  "params": {
-    "supported_macros": [
-    {
-      "macro": "{MEDIA_BUY_ID}",
-      "category": "identity",
-      "description": "AdCP media buy identifier",
-      "required": false,
-      "privacy_sensitive": false,
-      "example_value": "mb_spring_2025"
-    },
-    {
-      "macro": "{DEVICE_ID}",
-      "category": "identity",
-      "description": "Mobile advertising ID (IDFA/AAID)",
-      "required": false,
-      "privacy_sensitive": true,
-      "example_value": "ABC-123-DEF-456"
-    },
+  "macro_resolution_capabilities": [
     {
-      "macro": "{GDPR}",
-      "category": "privacy",
-      "description": "GDPR applicability flag",
-      "required": true,
-      "privacy_sensitive": false,
-      "example_value": "1"
+      "dialect": "adcp",
+      "dialect_semantic": "GDPR_CONSENT",
+      "mapping_status": "verified_universal",
+      "universal_semantic": "GDPR_CONSENT",
+      "operation": "resolve_value",
+      "performed_by": "seller",
+      "supported_contexts": ["url_query_value"],
+      "supported_encodings": [{ "kind": "rfc3986", "depth": 1 }]
     }
-    ],
-    "vast_macros_supported": true
+  ],
+  "params": {
+    "vast_versions": ["4.2"]
   }
 }
 ```
 
+Legacy named formats may still expose `supported_macros` as an array of universal macro names. That is a compatibility projection, not proof of actor, native dialect, context, or encoding support.
+
 ### 2. Include Macros in Creatives
 
 Add macro placeholders in your tracking URLs using `{MACRO_NAME}` syntax:
@@ -523,6 +708,8 @@ URL's query-parameter values. Each macro maps to either a **native** ad-server t
 (left raw, filled by the ad server at impression time) or a concrete **value** the
 agent already knows (substituted now, percent-encoded per RFC 3986):
 
+The behavior below is the established undeclared-token compatibility path. With occurrence declarations, a `native` mapping implements `translate_to_native` and emits the target declaration, while a concrete value follows the declaration's exact encoding profile. The helper's safety and privacy diagnostics are unchanged in either mode.
+
 ```typescript
 import { translateUniversalMacros } from '@adcp/sdk';
 
@@ -692,7 +879,7 @@ if (LIMIT_AD_TRACKING == 1 || DEVICE_ID == '' || DEVICE_ID == '00000000-0000-000
 
 ### URL Encoding
 
-No need to URL-encode macro placeholders. The ad server handles encoding of actual values automatically.
+Do not URL-encode the placeholder token itself. Supply raw values to the actor named by the occurrence declaration; that actor applies the declaration's exact encoding profile. Depending on the execution path, the actor may be the seller, source ad server, or request executor.
 
 **Example**:
 ```
@@ -700,11 +887,11 @@ No need to URL-encode macro placeholders. The ad server handles encoding of actu
 ✅ CORRECT: https://track.com/imp?device={DEVICE_ID}
 ```
 
-The ad server will URL-encode the actual value when replacing the macro.
+The declared actor encodes the concrete value exactly as specified. Callers must not pre-encode values, and downstream actors must not add an undeclared pass.
 
 ### Template Syntax
 
-AdCP macro-bearing URLs validate as [RFC 6570 URI templates (Level 1)](https://datatracker.ietf.org/doc/html/rfc6570#section-1.2) — simple `{var}` substitution only. Level 2–4 operators (`{+SKU}`, `{#SKU}`, `{.SKU}`, `{/SKU}`, `{;SKU}`, `{?SKU}`, `{&SKU}`) are **not** used by AdCP and must not appear in manifests. The ad server performs literal string replacement, not RFC 6570 expansion.
+AdCP macro-bearing URLs are not RFC 6570 templates. Plain URLs retain ordinary absolute HTTP(S) URI validation. For structural validation, verifiers mask recognized token lexical forms (`{NAME}`, `${NAME}`, `[NAME]`, and `%%NAME%%`) with an RFC 3986 unreserved sentinel and validate the resulting absolute HTTP(S) URI. This masking applies whether the occurrence is declared or travels on the undeclared 3.x compatibility path; it assigns no meaning, actor, or encoding and does not change the original bytes. RFC 6570 operators (`{+SKU}`, `{#SKU}`, `{?SKU}`, and similar forms) have no special expansion meaning. Processing is literal token replacement only when an applicable declaration or the explicit legacy helper authorizes it.
 
 ## Implementation Notes for Sales Agents
 
@@ -780,7 +967,7 @@ This separation is inherited from IAB OpenRTB Native: a click has **exactly one
 
 **Preserving the buyer's clickthrough parameters.** Inserting a click macro can strip query parameters already present on the buyer-supplied clickthrough URL — including ones the agent does not recognize, such as a buyer-side vendor's click identifier — which silently breaks downstream attribution. An agent that forwards these parameters applies the encoding discipline [Substitution safety](#substitution-safety-catalog-item-macros) defines for catalog-item values (Unicode NFC normalization, then percent-encoding to the RFC 3986 `unreserved` set) to any value derived from buyer- or third-party-supplied data, so preservation does not reopen URL-context breakout, CRLF injection, or bidi spoofing. Whether to make parameter preservation a normative requirement is part of the click-tracking proposal under working-group review ([#5693](https://github.com/adcontextprotocol/adcp/issues/5693)).
 
-**Getting a buyer's click identifier onto the landing.** A `click_tracker` is a count beacon: it records the click but does not place its identifier into the user's landing session, because only `landing_page_url` is navigated. When a buyer needs its click identifier to reach the landing (for click-level conversion attribution), the reliable, redirect-free pattern is to put that identifier directly on the `landing_page_url` it supplies — either as a literal value (`&buyer_click_id=abc123`) or composed from an AdCP macro the buyer controls (`&buyer_click_id={CREATIVE_ID}`, expanded by the sales agent at serve time). `{buyer_click_id}` is not itself an AdCP macro — the macro set is a closed registry (see [Available Macros](#available-macros-by-format)), so the buyer supplies the value, not a new token. Because the identifier rides on the one navigated URL, no party's redirect has to be the terminal hop. This works for any identifier the buyer can supply or derive ahead of serve time, and avoids multi-party redirect chaining entirely.
+**Getting a buyer's click identifier onto the landing.** A `click_tracker` is a count beacon: it records the click but does not place its identifier into the user's landing session, because only `landing_page_url` is navigated. When a buyer needs its click identifier to reach the landing (for click-level conversion attribution), the reliable, redirect-free pattern is to put that identifier directly on the `landing_page_url` it supplies — either as a literal value (`&buyer_click_id=abc123`) or composed from an AdCP macro the buyer controls (`&buyer_click_id={CREATIVE_ID}`, expanded by the sales agent at serve time). `{buyer_click_id}` is not itself an AdCP universal macro — that universal set is closed even though qualified vendor dialects remain extensible — so the buyer supplies the value, not a new universal token. Because the identifier rides on the one navigated URL, no party's redirect has to be the terminal hop. This works for any identifier the buyer can supply or derive ahead of serve time, and avoids multi-party redirect chaining entirely.
 
 Identifiers that can only be minted at click time (inside a vendor's own redirect) cannot survive on a count beacon, and routing the user *through* the vendor's redirect so its identifier lands requires a chaining contract AdCP does not define. A buyer-declarable "this tracker must be in the navigation path" slot semantic is under working-group discussion ([#5693](https://github.com/adcontextprotocol/adcp/issues/5693)); until it lands, the count beacon is the default and in-path identifier survival is out of scope.
 
diff --git a/docs/protocol/get_adcp_capabilities.mdx b/docs/protocol/get_adcp_capabilities.mdx
index 795e4aa46a..33aa144e70 100644
--- a/docs/protocol/get_adcp_capabilities.mdx
+++ b/docs/protocol/get_adcp_capabilities.mdx
@@ -680,6 +680,7 @@ Buyers discover AXE support via `get_adcp_capabilities` and filter products to A
 | Field | Type | Description |
 |-------|------|-------------|
 | `vast_versions` | string[] | VAST versions supported (e.g., `["4.0", "4.1", "4.2", "4.3"]`) |
+| `macro_resolution_capabilities` | object[] | Seller-wide ceiling of resolvable macro dialects, semantics, and URL-encoding depths. Product format options remain binding. |
 | `mraid_versions` | string[] | MRAID versions supported |
 | `vpaid` | boolean | VPAID support |
 | `simid` | boolean | SIMID support |
@@ -949,6 +950,9 @@ Creative protocol capabilities. Only present if `creative` is in `supported_prot
 | Field | Type | Description |
 |-------|------|-------------|
 | `supports_compliance` | boolean | When `true`, this creative agent can process briefs with compliance requirements and validate them against its canonical supported-format declarations. |
+| `has_creative_library` | boolean | When `true`, the agent exposes reusable [`sync_creatives`](/docs/creative/task-reference/sync_creatives) and `list_creatives` library operations. |
+| `supports_revisions` | boolean | When `true`, the library accepts buyer-authored immutable `revision_id` values and preserves them through sync echo, current readback, review attribution, and revision-homogeneous delivery rows. Requires `has_creative_library: true`. Does not imply revision history, rollback, or staged activation. |
+| `representation_resolution` | object | Destination-sales-agent opt-in to accept a complete `creative_representation_set` on [`build_creative`](/docs/creative/task-reference/build_creative), verify its revision digest, and select one compatible `representation_id` against that seller's current product and execution contract using an advertised deterministic strategy. Standalone creative agents cannot advertise seller-bound resolution. Absence means the caller selects before sending a seller-bound manifest; the agent cannot guess. See [creative representation sets](/docs/creative/representation-sets). |
 | `supported_formats` | object[] | Canonical creative operation catalog. New 3.2 producers MUST emit a stable `capability_id`, a full canonical `format` declaration, and explicit `operations` (`build`, `validate`, `preview`). Exact publisher support carries `{publisher_domain, format_option_id}` inside `format`; generic capabilities declare a satisfiable canonical parameter envelope. For 3.x compatibility, consumers accept entries without `capability_id` and interpret absent `operations` as `build`; such entries can be matched by contract but not selected through a capability-ID route. Replaces [`list_creative_formats`](/docs/creative/task-reference/list_creative_formats) in 3.2. |
 | `preview` | object | Per-route [`preview_creative`](/docs/creative/task-reference/preview_creative) declaration. `routes[].capability_id` names `supported_formats[]` entries whose `operations` includes `preview`; `rendering_origin` reports `platform_native` or `agent_approximation` per route. This self-description is informational and never grants authority; only a matching publisher placement `preview_provider` delegation does. See [rendering authority](/docs/creative/canonical-formats#rendering-authority-and-fallback-order). |
 | `supports_transformers` | boolean | When `true`, this creative agent offers account-scoped transformers — the selectable units of build capability (voices, models, styles) discovered via [`list_transformers`](/docs/creative/task-reference/list_transformers) and selected with `transformer_id` (plus the typed `config` bag) on [`build_creative`](/docs/creative/task-reference/build_creative). When `false` or absent, the agent does not expose transformers; `list_transformers` is unavailable and `build_creative` ignores `transformer_id`/`config`. Pre-call discriminator for routing across creative agents. |
@@ -1636,6 +1640,29 @@ const buy = await client.createMediaBuy({
       "axe_integrations": ["https://axe.example.com"],
       "creative_specs": {
         "vast_versions": ["4.0", "4.1", "4.2", "4.3"],
+        "macro_resolution_capabilities": [
+          {
+            "dialect": "adcp",
+            "dialect_semantic": "GDPR_CONSENT",
+            "mapping_status": "verified_universal",
+            "universal_semantic": "GDPR_CONSENT",
+            "operation": "resolve_value",
+            "performed_by": "seller",
+            "supported_contexts": ["url_query_value"],
+            "supported_encodings": [{ "kind": "rfc3986", "depth": 1 }]
+          },
+          {
+            "dialect": "iab_vast",
+            "dialect_namespace": "https://interactiveadvertisingbureau.github.io/vast/vast4macros/vast4-macros-latest.html",
+            "dialect_revision": "git:e0858cd714474bf17ef61065097456d7643ff838",
+            "dialect_semantic": "PLAYERSTATE",
+            "mapping_status": "dialect_defined",
+            "operation": "resolve_value",
+            "performed_by": "request_executor",
+            "supported_contexts": ["url_query_value"],
+            "supported_encodings": [{ "kind": "iab_vast_uri", "depth": 1 }]
+          }
+        ],
         "mraid_versions": ["3.0"],
         "vpaid": false,
         "simid": true
@@ -1817,6 +1844,10 @@ An agent can implement multiple protocols from a single endpoint. This is common
     "has_creative_library": true,
     "supports_generation": true,
     "supports_transformation": false,
+    "representation_resolution": {
+      "supported": true,
+      "strategies": ["representation_order", "highest_compatible_vast"]
+    },
     "supports_compliance": false,
     "bills_through_adcp": true,
     "supported_formats": [
@@ -1843,6 +1874,7 @@ This agent supports:
 
 - **Media Buy Protocol**: Product discovery, media buying, delivery reporting
 - **Creative Protocol**: Creative library management, AI-powered creative generation, variant-level delivery analytics via [`get_creative_delivery`](/docs/creative/task-reference/get_creative_delivery)
+- **Delivery representation resolution**: Deterministic selection from a `CreativeRepresentationSet` by the destination sales agent; absence of `representation_resolution` means callers must select before sending a seller-bound manifest, and standalone creative agents cannot claim seller deliverability
 - **Shared account**: A single account established via `sync_accounts` applies to both protocols
 
 When `supported_protocols` includes `"creative"`, inspect the `creative` capability block for the tasks and canonical formats this endpoint actually supports. [`list_creative_formats`](/docs/creative/task-reference/list_creative_formats) is deprecated in 3.2. See [Creative capabilities on sales agents](/docs/creative/sales-agent-creative-capabilities).
diff --git a/docs/snippets/compliance-error-codes.mdx b/docs/snippets/compliance-error-codes.mdx
index b24052e3bd..a09e182c2e 100644
--- a/docs/snippets/compliance-error-codes.mdx
+++ b/docs/snippets/compliance-error-codes.mdx
@@ -49,6 +49,8 @@ description: "Canonical AdCP error codes with recovery classifications, remediat
 | `CREATIVE_LOCALE_NOT_ACCEPTED` | correctable | supply or assign a creative variant matching every in-scope format option's accepted_language_ranges, narrow placement scope, choose a compatible format option, or change an ineligible serve_default |
 | `CREATIVE_NOT_FOUND` | correctable | verify creative_id via list_creatives, or sync_creatives to register it |
 | `CREATIVE_REJECTED` | correctable | revise the creative according to the applicable advertising policy or validated accessibility criteria |
+| `CREATIVE_REPRESENTATION_UNRESOLVED` | correctable | inspect every error.details.representation_rejections entry, then choose a compatible format option or supply a compatible representation |
+| `CREATIVE_REVISION_CONTENT_MISMATCH` | correctable | resend the exact content previously bound to this revision_id, or mint a new revision_id for changed content |
 | `CREATIVE_VALUE_NOT_ALLOWED` | correctable | pick a value from error.details.allowed_values (or re-fetch the format) and resubmit |
 | `CREDENTIAL_IN_ARGS` | terminal | do NOT auto-retry — auto-retry re-logs the credential on each attempt. Move authentication material or caller-supplied trust material out of request args (top-level, <code>{"context"}</code>, <code>{"ext"}</code>, any nested location) onto the relevant transport authentication/trust channel or account provisioning path (Authorization: Bearer, RFC 9421 signature/JWKS, mTLS, MCP/A2A authentication framing); rotate any leaked credential, then resubmit |
 | `EVALUATOR_AGENT_NOT_ACCEPTED` | correctable | replace the evaluator agent_url (evaluator.feature_agent.agent_url or the evaluator agent-form agent_url) with one from the seller's published accepted_verifiers, or drop the evaluator agent pointer to fall back to seller-default ranking |
@@ -73,6 +75,7 @@ description: "Canonical AdCP error codes with recovery classifications, remediat
 | `INVALID_USAGE_DATA` | correctable | check required fields for the vendor type (vendor_cost, currency, account at minimum), fix invalid values, and resubmit |
 | `IO_REQUIRED` | correctable | review the proposal's insertion_order, accept terms, and include io_acceptance on accept_proposal; use create_media_buy only for 3.x compatibility |
 | `ITEM_VALIDATION_FAILED` | correctable | check item_issues for per-item rejection reasons and fix the offending items |
+| `MACRO_RESOLUTION_FAILED` | correctable | inspect error.details.macro_resolution_results and route to a resolver that supports the declared dialect, semantic, owner, and encoding depth |
 | `MEDIA_BUY_NOT_FOUND` | correctable | verify media_buy_id; for legacy correlation use get_media_buys plus context, such as context.internal_campaign_id |
 | `MULTI_FINALIZE_UNSUPPORTED` | correctable | sequence single-proposal finalize calls — one finalize entry per get_products refine[] call or per refine_proposals refinements[] call |
 | `NOT_CANCELLABLE` | correctable | check the seller's cancellation policy or contact the seller |
@@ -119,7 +122,7 @@ description: "Canonical AdCP error codes with recovery classifications, remediat
 | `UNSUPPORTED_PROVISIONING` | correctable | re-issue with the entry shape the seller supports — <code>{"account: {account_id: ...}"}</code> for settings-update sellers with account-id namespaces, or <code>{"brand+operator+billing"}</code> for provisioning sellers; check seller documentation or capability declaration for which modes are implemented |
 | `VALIDATION_ERROR` | correctable | review error details and fix field values |
 | `VAST_PARSE_FAILED` | correctable | inspect error.details.reason (not_xml, no_vast_root, no_ad, no_media_file), fix the VAST document, and resubmit |
-| `VAST_VERSION_MISMATCH` | correctable | re-tag with a version from error.details.supported_versions, or correct the asset's declared vast_version to match the document |
+| `VAST_VERSION_MISMATCH` | correctable | inspect error.details.mismatch_reason and the corresponding acceptance-set or observed-document fields; select a compatible source representation or correct the offending VAST document |
 | `VAST_WRAPPER_DEPTH_EXCEEDED` | correctable | inspect error.details.reason (depth, loop, timeout); flatten the wrapper chain, reduce redirects below the format's max_wrapper_depth, or fix the failing hop |
 | `VERSION_UNSUPPORTED` | correctable | re-pin to a release in supported_versions and retry, or call get_adcp_capabilities without a version pin to discover supported_versions |
 
@@ -458,6 +461,24 @@ Referenced creative does not exist in the agent's creative library. Recovery: co
 
 Creative failed content-policy, brand-safety, or accessibility review. For deadline violations, see CREATIVE_DEADLINE_EXCEEDED. Accessibility failures SHOULD use structured details conforming to error-details/accessibility-violation.json. Recovery: correctable (revise the creative according to the applicable policy or validated accessibility criteria).
 
+</Accordion>
+<a id="error-code-creative-representation-unresolved"></a>
+
+<Accordion title="CREATIVE_REPRESENTATION_UNRESOLVED — correctable">
+
+**Suggested action:** inspect every error.details.representation_rejections entry, then choose a compatible format option or supply a compatible representation
+
+No representation in a CreativeRepresentationSet is compatible with the selected target capability or product format option. The resolver MUST retain the complete representation set and MUST include one <code>{"error.details.representation_rejections[]"}</code> entry per candidate, conforming to <code>{"error-details/creative-representation-unresolved.json"}</code>; silent seller guessing is forbidden. Recovery: correctable (choose a compatible product/format option, add a compatible representation under a new revision, or fix the rejected asset contract).
+
+</Accordion>
+<a id="error-code-creative-revision-content-mismatch"></a>
+
+<Accordion title="CREATIVE_REVISION_CONTENT_MISMATCH — correctable">
+
+**Suggested action:** resend the exact content previously bound to this revision_id, or mint a new revision_id for changed content
+
+A sync_creatives item reused a revision_id for different canonical revision content under the same creative_id. Revision identity is scoped to the parent creative and immutable after first acceptance. Sellers MUST evaluate the buyer input before transcoding or normalization, MUST leave the prior creative state unchanged, and SHOULD return details conforming to error-details/creative-revision-content-mismatch.json. Distinct from IDEMPOTENCY_CONFLICT: idempotency_key protects one request replay window, while revision identity protects creative content across requests and retention. Recovery: correctable (resend the exact content previously bound to this revision_id, or mint a new revision_id for the changed content).
+
 </Accordion>
 <a id="error-code-creative-value-not-allowed"></a>
 
@@ -716,6 +737,15 @@ The committed proposal requires a signed insertion order but no io_acceptance wa
 
 One or more catalog items failed schema validation during sync_catalogs. Recovery: correctable (check item_issues for per-item rejection reasons and fix the offending items).
 
+</Accordion>
+<a id="error-code-macro-resolution-failed"></a>
+
+<Accordion title="MACRO_RESOLUTION_FAILED — correctable">
+
+**Suggested action:** inspect error.details.macro_resolution_results and route to a resolver that supports the declared dialect, semantic, owner, and encoding depth
+
+One or more declared creative macro tokens cannot be resolved or safely preserved under the selected product and seller capability intersection. Sellers MUST include per-token <code>{"error.details.macro_resolution_results"}</code>, conforming to <code>{"error-details/macro-resolution-failed.json"}</code>; unknown or ambiguous tokens remain byte-preserved and MUST NOT receive guessed values. Recovery: correctable (route to a compatible execution path, correct the verified declaration, or assign the proper downstream resolver).
+
 </Accordion>
 <a id="error-code-media-buy-not-found"></a>
 
@@ -1164,9 +1194,9 @@ A submitted <code>{"vast"}</code> asset failed document-level validation: the in
 
 <Accordion title="VAST_VERSION_MISMATCH — correctable">
 
-**Suggested action:** re-tag with a version from error.details.supported_versions, or correct the asset's declared vast_version to match the document
+**Suggested action:** inspect error.details.mismatch_reason and the corresponding acceptance-set or observed-document fields; select a compatible source representation or correct the offending VAST document
 
-A submitted <code>{"vast"}</code> asset's document declares a <code>{"<VAST version>"}</code> attribute that does not match the asset's declared <code>{"vast_version"}</code>, does not satisfy the format's <code>{"vast_version"}</code> requirement, or is not in the seller's declared <code>{"creative_specs.vast_versions"}</code>. Returned by sellers performing document-level VAST validation (<code>{"creative_specs.vast_validation"}</code> of <code>{"document"}</code> or <code>{"wrapper"}</code>). Distinct from <code>{"VERSION_UNSUPPORTED"}</code> (AdCP protocol version negotiation, unrelated to creative documents). Sellers SHOULD set <code>{"error.field"}</code> to the offending asset path and SHOULD include the accepted versions in <code>{"error.details.supported_versions"}</code>. Recovery: correctable (re-tag with an accepted VAST version, or correct the asset's declared <code>{"vast_version"}</code>).
+A submitted <code>{"vast"}</code> asset is version-incompatible when its exact <code>{"vast_version"}</code> is absent from the intersection of the selected product format option's <code>{"params.vast_versions"}</code> and the seller's <code>{"execution.creative_specs.vast_versions"}</code>, or when an inspected document violates its applicable VAST version rule. Modern <code>{"error.details"}</code> MUST conform to <code>{"error-details/vast-version-mismatch.json"}</code>: acceptance failures carry <code>{"mismatch_reason: asset_outside_acceptance"}</code>, <code>{"asset_vast_version"}</code>, <code>{"product_vast_versions"}</code>, and <code>{"seller_vast_versions"}</code>, plus <code>{"format_option_ref"}</code> only when the selected option is addressable; inspected-document failures carry <code>{"mismatch_reason: document_version_mismatch"}</code>, <code>{"asset_vast_version"}</code>, <code>{"observed_document_vast_version"}</code>, and <code>{"document_role"}</code>. Only the submitted document is compared for equality with the asset declaration; wrapper and terminal documents are checked against the acceptance intersection. The deprecated <code>{"supported_versions"}</code> field remains accepted for older 3.x peers. Distinct from <code>{"VERSION_UNSUPPORTED"}</code>, which concerns AdCP protocol negotiation. Recovery: correctable (select a source VAST representation in the compatibility intersection or correct the offending document; never relabel the asset).
 
 </Accordion>
 <a id="error-code-vast-wrapper-depth-exceeded"></a>
diff --git a/package.json b/package.json
index 7f92b0e26c..4bc245c008 100644
--- a/package.json
+++ b/package.json
@@ -27,7 +27,7 @@
     "deploy:cdn-artifacts-cutover:dry-run": "wrangler deploy --config workers/artifact-cdn/wrangler.cutover.toml --dry-run",
     "verify:cdn-artifacts-cutover": "node scripts/verify-cdn-artifacts-cutover.mjs",
     "typecheck": "tsc --project server/tsconfig.json --noEmit",
-    "test:schemas": "node tests/schema-validation.test.cjs && node --test tests/outcome-target.test.cjs tests/trusted-match-offer-creative-data.test.cjs tests/accessibility-violation-details.test.cjs tests/portfolio-routing-scope.test.cjs tests/catalog-item-availability-updates.test.cjs tests/compact-product-lifecycle-storyboards.test.cjs tests/timezone-resolution-storyboards.test.cjs tests/schema-deprecation-metadata.test.cjs tests/products-only-brief-compatibility.test.cjs tests/async-identity-convergence.test.cjs tests/creative-rotation.test.cjs tests/metric-identity-coherence.test.cjs tests/sort-contract-delivery-reporting.test.cjs tests/time-based-views-contract.test.cjs tests/metric-qualifier-parity.test.cjs tests/requested-metrics-contract.test.cjs tests/auto-breakdown-negotiation-contract.test.cjs tests/format-delivery-reporting-contract.test.cjs tests/lint-schema-enum-drift.test.cjs tests/synthetic-depiction.test.cjs tests/creative-rendering-authority.test.cjs && npm run test:premium-display-formats && npm run test:geo-region-targeting",
+    "test:schemas": "node tests/schema-validation.test.cjs && node --test tests/outcome-target.test.cjs tests/trusted-match-offer-creative-data.test.cjs tests/accessibility-violation-details.test.cjs tests/portfolio-routing-scope.test.cjs tests/catalog-item-availability-updates.test.cjs tests/compact-product-lifecycle-storyboards.test.cjs tests/timezone-resolution-storyboards.test.cjs tests/schema-deprecation-metadata.test.cjs tests/products-only-brief-compatibility.test.cjs tests/async-identity-convergence.test.cjs tests/creative-rotation.test.cjs tests/creative-revisions.test.cjs tests/creative-delivery-contracts.test.cjs tests/metric-identity-coherence.test.cjs tests/sort-contract-delivery-reporting.test.cjs tests/time-based-views-contract.test.cjs tests/metric-qualifier-parity.test.cjs tests/requested-metrics-contract.test.cjs tests/auto-breakdown-negotiation-contract.test.cjs tests/format-delivery-reporting-contract.test.cjs tests/lint-schema-enum-drift.test.cjs tests/synthetic-depiction.test.cjs tests/creative-rendering-authority.test.cjs && npm run test:premium-display-formats && npm run test:geo-region-targeting",
     "test:performance-feedback": "node --test --test-force-exit --test-timeout=30000 tests/performance-feedback-contract.test.cjs",
     "test:dist-schema-version-ids": "node --test --test-force-exit --test-timeout=30000 tests/dist-schema-version-ids.test.cjs",
     "test:examples": "node tests/example-validation-simple.test.cjs && npm run test:tmp-context-merge",
diff --git a/scripts/error-code-drift-dispositions.json b/scripts/error-code-drift-dispositions.json
index 6b27017652..64a156e42d 100644
--- a/scripts/error-code-drift-dispositions.json
+++ b/scripts/error-code-drift-dispositions.json
@@ -1,6 +1,16 @@
 {
   "$comment": "Disposition registry for error codes that are present in the current source enum but absent from the 3.0.x maintenance branch. Read by scripts/lint-error-code-drift.cjs. Every code in the AHEAD set (main \\ 3.0.x) MUST have an entry here; codes missing from this file fail the lint. Policy: 3.0.x is wire-stable. Adding a new enum value is a wire change (a 3.0.x receiver decoding a 3.1 sender's error.code cannot match against an enum it doesn't carry, and JSON Schema enum is closed by default), so the default disposition for any new code is 'held-for-next-minor' with target_version='3.1'. 'held-for-next-major' (target_version='4.0') is for codes that should defer past 3.x \u2014 typically because the surrounding subsystem is being reworked. 'backport-pending' is reserved for prose-only or doc-comment-only changes to a code that already exists on 3.0.x; the lint rejects backport-pending entries whose code is not on 3.0.x. Valid `disposition` values: 'backport-pending', 'held-for-next-minor', 'held-for-next-major', 'unclassified'. `target_version` (required for held-*) is a 'MAJOR.MINOR' string. When a code lands on 3.0.x its entry SHOULD be removed; the lint flags stale entries.",
   "dispositions": {
+    "CREATIVE_REPRESENTATION_UNRESOLVED": {
+      "disposition": "held-for-next-minor",
+      "target_version": "3.2",
+      "note": "CreativeRepresentationSet resolution returns one structured rejection per retained representation when no candidate matches the selected destination. New 3.2 creative wire code — held for 3.2."
+    },
+    "MACRO_RESOLUTION_FAILED": {
+      "disposition": "held-for-next-minor",
+      "target_version": "3.2",
+      "note": "Declared creative macro compatibility failed against the product and seller execution intersection. New 3.2 creative wire code — held for 3.2."
+    },
     "ACCOUNT_IDENTITY_CONFLICT": {
       "disposition": "held-for-next-minor",
       "target_version": "3.2",
@@ -51,6 +61,11 @@
       "target_version": "3.1",
       "note": "Native creative-localization assignment rejection when a package's effective format locale_policy has no eligible materialized variant. New 3.1 creative surface; wire change — held for 3.1."
     },
+    "CREATIVE_REVISION_CONTENT_MISMATCH": {
+      "disposition": "held-for-next-minor",
+      "target_version": "3.2",
+      "note": "Creative revision identity rejects reuse of one buyer revision_id for different input content under the same creative_id. Additive 3.2 creative-library vocabulary; held for 3.2."
+    },
     "FEED_FETCH_FAILED": {
       "disposition": "held-for-next-minor",
       "target_version": "3.1",
diff --git a/static/compliance/source/protocols/creative/scenarios/creative_revision_identity.yaml b/static/compliance/source/protocols/creative/scenarios/creative_revision_identity.yaml
new file mode 100644
index 0000000000..e253934541
--- /dev/null
+++ b/static/compliance/source/protocols/creative/scenarios/creative_revision_identity.yaml
@@ -0,0 +1,201 @@
+id: creative/creative_revision_identity
+version: "1.0.0"
+introduced_in: "3.2"
+title: "Creative revision identity is immutable and reads back exactly"
+category: creative
+summary: "Verifies capability-gated revision echo, immutable content reuse, non-mutation on mismatch, and current library readback."
+track: creative
+
+required_tools:
+  - get_adcp_capabilities
+  - sync_creatives
+  - list_creatives
+
+requires_capability:
+  path: creative.supports_revisions
+  equals: true
+
+narrative: |
+  An agent that advertises creative.supports_revisions commits to one immutable
+  buyer-authored input state for each (creative_id, revision_id). The buyer
+  creates a revision, attempts to reuse the same ID with changed assets, and
+  confirms that the failed probe did not mutate the accepted creative.
+
+agent:
+  interaction_model: stateful_push
+  capabilities:
+    - has_creative_library
+    - supports_revisions
+  examples:
+    - "Creative libraries that preserve buyer revision identity"
+
+caller:
+  role: buyer_agent
+  example: "Pinnacle Agency (buyer)"
+
+prerequisites:
+  description: |
+    The caller has two image URLs. Only the first may become the stored content
+    for revision rev_launch_1.
+  test_kit: "test-kits/acme-outdoor.yaml"
+
+phases:
+  - id: discover_revision_support
+    title: "Discover revision support"
+    steps:
+      - id: get_revision_capability
+        title: "Confirm the revision contract"
+        task: get_adcp_capabilities
+        schema_ref: "protocol/get-adcp-capabilities-request.json"
+        response_schema_ref: "protocol/get-adcp-capabilities-response.json"
+        doc_ref: "/protocol/get_adcp_capabilities"
+        comply_scenario: capability_discovery
+        stateful: false
+        sample_request:
+          context:
+            correlation_id: "creative_revision_identity--capability"
+        expected: |
+          Return creative.has_creative_library and creative.supports_revisions
+          as true before the buyer relies on revision identity.
+        validations:
+          - check: response_schema
+            description: "Response matches get-adcp-capabilities-response.json"
+          - check: field_value
+            path: "creative.has_creative_library"
+            value: true
+            description: "Revision support is backed by a creative library"
+          - check: field_value
+            path: "creative.supports_revisions"
+            value: true
+            description: "The agent opts into immutable revision handling"
+
+  - id: bind_revision
+    title: "Bind the first accepted revision"
+    steps:
+      - id: sync_initial_revision
+        title: "Create revision rev_launch_1"
+        task: sync_creatives
+        schema_ref: "creative/sync-creatives-request.json"
+        response_schema_ref: "creative/sync-creatives-response.json"
+        doc_ref: "/creative/task-reference/sync_creatives#creative-revisions"
+        comply_scenario: creative_flow
+        stateful: true
+        sample_request:
+          account: &revision_account
+            brand:
+              domain: "acmeoutdoor.example"
+            operator: "pinnacle-agency.example"
+            sandbox: true
+          creatives:
+            - creative_id: "revision_launch_banner"
+              revision_id: "rev_launch_1"
+              name: "Launch banner revision one"
+              format_kind: "image"
+              assets:
+                image:
+                  asset_type: "image"
+                  url: "https://cdn.pinnacle-agency.example/revision-launch-v1.png"
+                  width: 300
+                  height: 250
+          idempotency_key: "$generate:uuid_v4#creative_revision_identity_initial"
+          context:
+            correlation_id: "creative_revision_identity--initial"
+        expected: |
+          Accept the creative and echo rev_launch_1 exactly on a created,
+          updated, or unchanged result.
+        validations:
+          - check: response_schema
+            description: "Response matches sync-creatives-response.json"
+          - check: field_value
+            path: "creatives[0].creative_id"
+            value: "revision_launch_banner"
+            description: "The result identifies the submitted creative"
+          - check: field_value
+            path: "creatives[0].revision_id"
+            value: "rev_launch_1"
+            description: "The accepted buyer revision echoes exactly"
+
+  - id: reject_revision_reuse
+    title: "Reject changed content under the bound ID"
+    steps:
+      - id: sync_changed_same_revision
+        title: "Attempt to replace the asset without a new revision"
+        task: sync_creatives
+        schema_ref: "creative/sync-creatives-request.json"
+        response_schema_ref: "creative/sync-creatives-response.json"
+        doc_ref: "/creative/task-reference/sync_creatives#creative-revisions"
+        comply_scenario: creative_flow
+        stateful: true
+        sample_request:
+          account: *revision_account
+          creatives:
+            - creative_id: "revision_launch_banner"
+              revision_id: "rev_launch_1"
+              name: "Changed bytes under the same revision"
+              format_kind: "image"
+              assets:
+                image:
+                  asset_type: "image"
+                  url: "https://cdn.pinnacle-agency.example/revision-launch-mutated.png"
+                  width: 300
+                  height: 250
+          idempotency_key: "$generate:uuid_v4#creative_revision_identity_mismatch"
+          context:
+            correlation_id: "creative_revision_identity--mismatch"
+        expected: |
+          Return a failed per-creative item carrying
+          CREATIVE_REVISION_CONTENT_MISMATCH. Do not echo revision_id on the
+          failed result and do not mutate the stored creative.
+        validations:
+          - check: response_schema
+            description: "The best-effort per-item failure remains schema-valid"
+          - check: field_value
+            path: "creatives[0].action"
+            value: "failed"
+            description: "Changed content under a bound revision is rejected"
+          - check: field_value
+            path: "creatives[0].errors[0].code"
+            value: "CREATIVE_REVISION_CONTENT_MISMATCH"
+            description: "The typed correctable mismatch error is returned"
+          - check: field_absent
+            path: "creatives[0].revision_id"
+            description: "Failed items do not claim an accepted revision"
+
+  - id: verify_non_mutation
+    title: "Read back the accepted revision and original asset"
+    steps:
+      - id: list_current_revision
+        title: "Confirm the mismatch probe changed nothing"
+        task: list_creatives
+        schema_ref: "creative/list-creatives-request.json"
+        response_schema_ref: "creative/list-creatives-response.json"
+        doc_ref: "/creative/task-reference/list_creatives"
+        comply_scenario: creative_flow
+        stateful: true
+        sample_request:
+          account: *revision_account
+          filters:
+            creative_ids: ["revision_launch_banner"]
+          context:
+            correlation_id: "creative_revision_identity--readback"
+        expected: |
+          Return exactly the current creative with rev_launch_1 and the original
+          accepted asset URL. The rejected replacement must not be visible.
+        validations:
+          - check: response_schema
+            description: "Response matches list-creatives-response.json"
+          - check: field_value
+            path: "creatives[0].creative_id"
+            value: "revision_launch_banner"
+            description: "The requested creative is returned"
+          - check: field_value
+            path: "creatives[0].revision_id"
+            value: "rev_launch_1"
+            description: "The current revision reads back exactly"
+          - check: field_value
+            path: "creatives[0].assets.image.url"
+            value: "https://cdn.pinnacle-agency.example/revision-launch-v1.png"
+            description: "The failed mismatch did not mutate stored content"
+          - check: field_absent
+            path: "creatives[1]"
+            description: "The exact creative_id filter returns one row"
diff --git a/static/compliance/source/test-vectors/creative-representation-resolution.json b/static/compliance/source/test-vectors/creative-representation-resolution.json
new file mode 100644
index 0000000000..e26c459063
--- /dev/null
+++ b/static/compliance/source/test-vectors/creative-representation-resolution.json
@@ -0,0 +1,247 @@
+{
+  "$schema": "./creative-representation-resolution.schema.json",
+  "vectors": [
+    {
+      "name": "paired redirect selected while inline alternative is retained",
+      "representation_set": {
+        "creative_id": "cr_display_1",
+        "revision_id": "rev_1",
+        "revision_content_digest": "sha256:dfab7f7290bba72f6826ee10186f7618d6b53b3037290f72b094294bceaf6835",
+        "name": "Display launch",
+        "representations": [
+          {
+            "representation_id": "source-inline",
+            "format_kind": "display_tag",
+            "assets": {
+              "serving_tag": {
+                "asset_type": "display_tag",
+                "delivery_type": "inline_markup",
+                "markup_type": "iframe_javascript",
+                "markup": "<iframe src=\"https://ads.acme-example.com/render\"></iframe>"
+              }
+            },
+            "source": { "system": "acme_ad_server", "source_representation": "iframe/JavaScript" }
+          },
+          {
+            "representation_id": "source-paired",
+            "format_kind": "display_tag",
+            "assets": {
+              "serving_tag": {
+                "asset_type": "display_tag",
+                "delivery_type": "paired_redirect",
+                "ad_request_url": "https://ads.acme-example.com/ad?slot=42",
+                "clickthrough_url": "https://click.acme-example.com/redirect"
+              }
+            },
+            "source": { "system": "acme_ad_server", "source_representation": "Internal Redirect" }
+          }
+        ]
+      },
+      "target": {
+        "format_kind": "display_tag",
+        "supported_delivery_types": ["paired_redirect"]
+      },
+      "seller": {},
+      "strategy": "representation_order",
+      "expected": {
+        "selected_representation_id": "source-paired",
+        "compatible_representation_ids": ["source-paired"],
+        "retained_representation_ids": ["source-inline", "source-paired"],
+        "rejections": [
+          {
+            "representation_id": "source-inline",
+            "code": "unsupported_delivery_type",
+            "message": "inline_markup is not accepted by the selected format option"
+          }
+        ]
+      }
+    },
+    {
+      "name": "highest VAST is selected only after product and seller intersection",
+      "representation_set": {
+        "creative_id": "cr_video_1",
+        "revision_id": "rev_1",
+        "revision_content_digest": "sha256:67d087e0a6e84185fc9b28d5854b1f9d90958ac902a3d569422af3ba69951154",
+        "name": "Video launch",
+        "representations": [
+          {
+            "representation_id": "source-vast-2",
+            "format_kind": "video_vast",
+            "assets": { "vast_tag": { "asset_type": "vast", "delivery_type": "url", "url": "https://video.acme-example.com/vast/2", "vast_version": "2.0" } },
+            "source": { "system": "acme_ad_server", "source_representation": "VAST 2.0 pre-fetch" }
+          },
+          {
+            "representation_id": "source-vast-3",
+            "format_kind": "video_vast",
+            "assets": { "vast_tag": { "asset_type": "vast", "delivery_type": "url", "url": "https://video.acme-example.com/vast/3", "vast_version": "3.0" } },
+            "source": { "system": "acme_ad_server", "source_representation": "VAST 3.0 pre-fetch" }
+          },
+          {
+            "representation_id": "source-vast-4",
+            "format_kind": "video_vast",
+            "assets": { "vast_tag": { "asset_type": "vast", "delivery_type": "url", "url": "https://video.acme-example.com/vast/4", "vast_version": "4.0" } },
+            "source": { "system": "acme_ad_server", "source_representation": "VAST 4.0 pre-fetch" }
+          }
+        ]
+      },
+      "target": { "format_kind": "video_vast", "vast_versions": ["3.0", "4.0"] },
+      "seller": { "vast_versions": ["3.0", "4.0", "4.1", "4.2"] },
+      "strategy": "highest_compatible_vast",
+      "expected": {
+        "selected_representation_id": "source-vast-4",
+        "compatible_representation_ids": ["source-vast-3", "source-vast-4"],
+        "retained_representation_ids": ["source-vast-2", "source-vast-3", "source-vast-4"],
+        "rejections": [
+          {
+            "representation_id": "source-vast-2",
+            "code": "vast_version_mismatch",
+            "message": "2.0 is outside the product and seller compatibility intersection"
+          }
+        ]
+      }
+    },
+    {
+      "name": "VAST 4.3 remains selectable when both layers accept it",
+      "representation_set": {
+        "creative_id": "cr_video_43",
+        "revision_id": "rev_1",
+        "revision_content_digest": "sha256:50b8b0eaac4f52d300cb991650742e9349b72aba9edc936386143646dc15fc8d",
+        "name": "Video 4.3",
+        "representations": [
+          {
+            "representation_id": "source-vast-43",
+            "format_kind": "video_vast",
+            "assets": { "vast_tag": { "asset_type": "vast", "delivery_type": "url", "url": "https://video.acme-example.com/vast/43", "vast_version": "4.3" } },
+            "source": { "system": "creative_server", "source_representation": "VAST 4.3" }
+          }
+        ]
+      },
+      "target": { "format_kind": "video_vast", "vast_versions": ["4.3"] },
+      "seller": { "vast_versions": ["4.2", "4.3"] },
+      "strategy": "highest_compatible_vast",
+      "expected": {
+        "selected_representation_id": "source-vast-43",
+        "compatible_representation_ids": ["source-vast-43"],
+        "retained_representation_ids": ["source-vast-43"],
+        "rejections": []
+      }
+    },
+    {
+      "name": "equal highest VAST versions use representation order as the tie break",
+      "representation_set": {
+        "creative_id": "cr_video_tie",
+        "revision_id": "rev_1",
+        "revision_content_digest": "sha256:2301a2ad0efbafb7c7ad3123afb8f23627f57e0c2a81cb2f46fe5cd56d774f86",
+        "name": "Video tie break",
+        "representations": [
+          {
+            "representation_id": "source-vast-4-primary",
+            "format_kind": "video_vast",
+            "assets": {
+              "vast_tag": {
+                "asset_type": "vast",
+                "delivery_type": "url",
+                "url": "https://video.acme-example.com/vast/4-primary",
+                "vast_version": "4.0"
+              }
+            },
+            "source": {
+              "system": "acme_ad_server",
+              "source_representation": "Primary VAST 4.0"
+            }
+          },
+          {
+            "representation_id": "source-vast-4-secondary",
+            "format_kind": "video_vast",
+            "assets": {
+              "vast_tag": {
+                "asset_type": "vast",
+                "delivery_type": "url",
+                "url": "https://video.acme-example.com/vast/4-secondary",
+                "vast_version": "4.0"
+              }
+            },
+            "source": {
+              "system": "acme_ad_server",
+              "source_representation": "Secondary VAST 4.0"
+            }
+          }
+        ]
+      },
+      "target": {
+        "format_kind": "video_vast",
+        "vast_versions": ["4.0"]
+      },
+      "seller": {
+        "vast_versions": ["4.0", "4.1", "4.2"]
+      },
+      "strategy": "highest_compatible_vast",
+      "expected": {
+        "selected_representation_id": "source-vast-4-primary",
+        "compatible_representation_ids": ["source-vast-4-primary", "source-vast-4-secondary"],
+        "retained_representation_ids": ["source-vast-4-primary", "source-vast-4-secondary"],
+        "rejections": []
+      }
+    },
+    {
+      "name": "no compatible representation returns one rejection for every retained candidate",
+      "representation_set": {
+        "creative_id": "cr_display_unresolved",
+        "revision_id": "rev_1",
+        "revision_content_digest": "sha256:dfab7f7290bba72f6826ee10186f7618d6b53b3037290f72b094294bceaf6835",
+        "name": "Display launch unresolved",
+        "representations": [
+          {
+            "representation_id": "source-inline",
+            "format_kind": "display_tag",
+            "assets": {
+              "serving_tag": {
+                "asset_type": "display_tag",
+                "delivery_type": "inline_markup",
+                "markup_type": "iframe_javascript",
+                "markup": "<iframe src=\"https://ads.acme-example.com/render\"></iframe>"
+              }
+            },
+            "source": { "system": "acme_ad_server", "source_representation": "iframe/JavaScript" }
+          },
+          {
+            "representation_id": "source-paired",
+            "format_kind": "display_tag",
+            "assets": {
+              "serving_tag": {
+                "asset_type": "display_tag",
+                "delivery_type": "paired_redirect",
+                "ad_request_url": "https://ads.acme-example.com/ad?slot=42",
+                "clickthrough_url": "https://click.acme-example.com/redirect"
+              }
+            },
+            "source": { "system": "acme_ad_server", "source_representation": "Internal Redirect" }
+          }
+        ]
+      },
+      "target": {
+        "format_kind": "display_tag",
+        "supported_delivery_types": ["tag_url"]
+      },
+      "seller": {},
+      "strategy": "representation_order",
+      "expected": {
+        "selected_representation_id": null,
+        "compatible_representation_ids": [],
+        "retained_representation_ids": ["source-inline", "source-paired"],
+        "rejections": [
+          {
+            "representation_id": "source-inline",
+            "code": "unsupported_delivery_type",
+            "message": "inline_markup is not accepted by the selected format option"
+          },
+          {
+            "representation_id": "source-paired",
+            "code": "unsupported_delivery_type",
+            "message": "paired_redirect is not accepted by the selected format option"
+          }
+        ]
+      }
+    }
+  ]
+}
diff --git a/static/compliance/source/test-vectors/creative-representation-resolution.schema.json b/static/compliance/source/test-vectors/creative-representation-resolution.schema.json
new file mode 100644
index 0000000000..a9cbda3c42
--- /dev/null
+++ b/static/compliance/source/test-vectors/creative-representation-resolution.schema.json
@@ -0,0 +1,61 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "creative-representation-resolution.schema.json",
+  "title": "Creative representation resolution vectors",
+  "type": "object",
+  "properties": {
+    "vectors": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": { "type": "string", "minLength": 1 },
+          "representation_set": { "$ref": "/schemas/core/creative-representation-set.json" },
+          "target": {
+            "type": "object",
+            "properties": {
+              "format_kind": { "type": "string" },
+              "supported_delivery_types": {
+                "type": "array",
+                "items": { "type": "string" }
+              },
+              "vast_versions": {
+                "type": "array",
+                "items": { "$ref": "/schemas/enums/vast-version.json" }
+              }
+            },
+            "required": ["format_kind"],
+            "additionalProperties": true
+          },
+          "seller": {
+            "type": "object",
+            "properties": {
+              "vast_versions": {
+                "type": "array",
+                "items": { "$ref": "/schemas/enums/vast-version.json" }
+              }
+            },
+            "additionalProperties": true
+          },
+          "strategy": { "type": "string", "enum": ["representation_order", "highest_compatible_vast"] },
+          "expected": {
+            "type": "object",
+            "properties": {
+              "selected_representation_id": { "type": ["string", "null"] },
+              "compatible_representation_ids": { "type": "array", "items": { "type": "string" } },
+              "retained_representation_ids": { "type": "array", "items": { "type": "string" } },
+              "rejections": {
+                "type": "array",
+                "items": { "$ref": "/schemas/core/representation-rejection.json" }
+              }
+            },
+            "required": ["selected_representation_id", "compatible_representation_ids", "retained_representation_ids", "rejections"]
+          }
+        },
+        "required": ["name", "representation_set", "target", "seller", "strategy", "expected"]
+      }
+    }
+  },
+  "required": ["vectors"]
+}
diff --git a/static/compliance/source/test-vectors/macro-processing.json b/static/compliance/source/test-vectors/macro-processing.json
new file mode 100644
index 0000000000..df842ed911
--- /dev/null
+++ b/static/compliance/source/test-vectors/macro-processing.json
@@ -0,0 +1,559 @@
+{
+  "$schema": "./macro-processing.schema.json",
+  "vectors": [
+    {
+      "name": "unknown token remains byte-identical",
+      "source": "https://track.acme-example.com/pixel?x=%%UNIDENTIFIED%%",
+      "declaration": {
+        "declaration_id": "unknown-token",
+        "token": "%%UNIDENTIFIED%%",
+        "dialect": "unknown",
+        "dialect_semantic": "unresolved",
+        "mapping_status": "unresolved",
+        "operation": "preserve",
+        "location": { "field": "url", "occurrence": 0, "context": "opaque" },
+        "encoding": { "kind": "none", "depth": 0 },
+        "required": false,
+        "unavailable_behavior": "preserve"
+      },
+      "seller_capabilities": [],
+      "product_capabilities": [],
+      "expected": {
+        "status": "preserved_for_downstream",
+        "reason": "preserved_unknown",
+        "output": "https://track.acme-example.com/pixel?x=%%UNIDENTIFIED%%"
+      }
+    },
+    {
+      "name": "declared preservation remains byte-identical without claiming a resolver",
+      "source": "https://track.acme-example.com/pixel?x=%%ACME_OPAQUE%%",
+      "declaration": {
+        "declaration_id": "vendor-preserve",
+        "token": "%%ACME_OPAQUE%%",
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "OPAQUE_HANDOFF",
+        "mapping_status": "dialect_defined",
+        "operation": "preserve",
+        "location": { "field": "url", "occurrence": 0, "context": "opaque" },
+        "encoding": { "kind": "none", "depth": 0 },
+        "required": false,
+        "unavailable_behavior": "preserve"
+      },
+      "seller_capabilities": [],
+      "product_capabilities": [],
+      "expected": {
+        "status": "preserved_for_downstream",
+        "reason": "preserved_for_downstream",
+        "output": "https://track.acme-example.com/pixel?x=%%ACME_OPAQUE%%"
+      }
+    },
+    {
+      "name": "unsupported dialect fails before looser semantic matching",
+      "source": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%",
+      "declaration": {
+        "declaration_id": "dialect-mismatch",
+        "token": "%%ACME_CLICK%%",
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "CLICK",
+        "mapping_status": "dialect_defined",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+        "encoding": { "kind": "rfc3986", "depth": 1 },
+        "required": true,
+        "unavailable_behavior": "reject"
+      },
+      "seller_capabilities": [{
+        "dialect": "adcp",
+        "dialect_semantic": "CLICK_URL",
+        "mapping_status": "verified_universal",
+        "universal_semantic": "CLICK_URL",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "supported_contexts": ["url_query_value"],
+        "supported_encodings": [{ "kind": "rfc3986", "depth": 1 }]
+      }],
+      "product_capabilities": [],
+      "expected": {
+        "status": "unsupported",
+        "reason": "dialect_unsupported",
+        "output": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%"
+      }
+    },
+    {
+      "name": "vendor namespace mismatch is explicit",
+      "source": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%",
+      "declaration": {
+        "declaration_id": "namespace-mismatch",
+        "token": "%%ACME_CLICK%%",
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "CLICK",
+        "mapping_status": "dialect_defined",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+        "encoding": { "kind": "rfc3986", "depth": 1 },
+        "required": true,
+        "unavailable_behavior": "reject"
+      },
+      "seller_capabilities": [{
+        "dialect": "vendor",
+        "dialect_namespace": "https://other-macros.example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "CLICK",
+        "mapping_status": "dialect_defined",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "supported_contexts": ["url_query_value"],
+        "supported_encodings": [{ "kind": "rfc3986", "depth": 1 }]
+      }],
+      "product_capabilities": [],
+      "expected": {
+        "status": "unsupported",
+        "reason": "namespace_mismatch",
+        "output": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%"
+      }
+    },
+    {
+      "name": "vendor registry revision mismatch is explicit",
+      "source": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%",
+      "declaration": {
+        "declaration_id": "revision-mismatch",
+        "token": "%%ACME_CLICK%%",
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "CLICK",
+        "mapping_status": "dialect_defined",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+        "encoding": { "kind": "rfc3986", "depth": 1 },
+        "required": true,
+        "unavailable_behavior": "reject"
+      },
+      "seller_capabilities": [{
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v2",
+        "dialect_semantic": "CLICK",
+        "mapping_status": "dialect_defined",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "supported_contexts": ["url_query_value"],
+        "supported_encodings": [{ "kind": "rfc3986", "depth": 1 }]
+      }],
+      "product_capabilities": [],
+      "expected": {
+        "status": "unsupported",
+        "reason": "revision_mismatch",
+        "output": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%"
+      }
+    },
+    {
+      "name": "dialect semantic mismatch is explicit",
+      "source": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%",
+      "declaration": {
+        "declaration_id": "semantic-mismatch",
+        "token": "%%ACME_CLICK%%",
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "CLICK",
+        "mapping_status": "dialect_defined",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+        "encoding": { "kind": "rfc3986", "depth": 1 },
+        "required": true,
+        "unavailable_behavior": "reject"
+      },
+      "seller_capabilities": [{
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "IMPRESSION",
+        "mapping_status": "dialect_defined",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "supported_contexts": ["url_query_value"],
+        "supported_encodings": [{ "kind": "rfc3986", "depth": 1 }]
+      }],
+      "product_capabilities": [],
+      "expected": {
+        "status": "unsupported",
+        "reason": "semantic_unsupported",
+        "output": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%"
+      }
+    },
+    {
+      "name": "requested operation must match exactly",
+      "source": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%",
+      "declaration": {
+        "declaration_id": "operation-mismatch",
+        "token": "%%ACME_CLICK%%",
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "CLICK",
+        "mapping_status": "dialect_defined",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+        "encoding": { "kind": "rfc3986", "depth": 1 },
+        "required": true,
+        "unavailable_behavior": "reject"
+      },
+      "seller_capabilities": [{
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "CLICK",
+        "mapping_status": "dialect_defined",
+        "operation": "translate_to_native",
+        "performed_by": "seller",
+        "supported_contexts": ["url_query_value"],
+        "translation_target": {
+          "token": "%%ACME_CLICK_NATIVE%%",
+          "dialect": "vendor",
+          "dialect_namespace": "https://macros.acme-example.com/registry",
+          "dialect_revision": "mapping-v1",
+          "dialect_semantic": "CLICK_NATIVE",
+          "mapping_status": "dialect_defined",
+          "next_operation": "resolve_value",
+          "performed_by": "seller",
+          "encoding": { "kind": "rfc3986", "depth": 1 }
+        }
+      }],
+      "product_capabilities": [],
+      "expected": {
+        "status": "unsupported",
+        "reason": "operation_unsupported",
+        "output": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%"
+      }
+    },
+    {
+      "name": "occurrence context must match exactly",
+      "source": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%",
+      "declaration": {
+        "declaration_id": "context-mismatch",
+        "token": "%%ACME_CLICK%%",
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "CLICK",
+        "mapping_status": "dialect_defined",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+        "encoding": { "kind": "rfc3986", "depth": 1 },
+        "required": true,
+        "unavailable_behavior": "reject"
+      },
+      "seller_capabilities": [{
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "CLICK",
+        "mapping_status": "dialect_defined",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "supported_contexts": ["url_path_segment"],
+        "supported_encodings": [{ "kind": "rfc3986", "depth": 1 }]
+      }],
+      "product_capabilities": [],
+      "expected": {
+        "status": "unsupported",
+        "reason": "context_unsupported",
+        "output": "https://track.acme-example.com/click?redirect=%%ACME_CLICK%%"
+      }
+    },
+    {
+      "name": "seller translates a universal token before downstream value resolution",
+      "source": "https://video.acme-example.com/event?cb={CACHEBUSTER}",
+      "value": "12345678",
+      "declaration": {
+        "declaration_id": "cachebuster-translation",
+        "token": "{CACHEBUSTER}",
+        "dialect": "adcp",
+        "dialect_semantic": "CACHEBUSTER",
+        "mapping_status": "verified_universal",
+        "universal_semantic": "CACHEBUSTER",
+        "operation": "translate_to_native",
+        "performed_by": "seller",
+        "translation_target": {
+          "token": "[CACHEBUSTING]",
+          "dialect": "iab_vast",
+          "dialect_namespace": "https://interactiveadvertisingbureau.github.io/vast/vast4macros/vast4-macros-latest.html",
+          "dialect_revision": "git:e0858cd714474bf17ef61065097456d7643ff838",
+          "dialect_semantic": "CACHEBUSTING",
+          "mapping_status": "verified_universal",
+          "universal_semantic": "CACHEBUSTER",
+          "next_operation": "resolve_value",
+          "performed_by": "request_executor",
+          "encoding": { "kind": "iab_vast_uri", "depth": 1 }
+        },
+        "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+        "encoding": { "kind": "none", "depth": 0 },
+        "required": true,
+        "unavailable_behavior": "reject"
+      },
+      "seller_capabilities": [
+        {
+          "dialect": "adcp",
+          "dialect_semantic": "CACHEBUSTER",
+          "mapping_status": "verified_universal",
+          "universal_semantic": "CACHEBUSTER",
+          "operation": "translate_to_native",
+          "performed_by": "seller",
+          "supported_contexts": ["url_query_value"],
+          "translation_target": {
+            "token": "[CACHEBUSTING]",
+            "dialect": "iab_vast",
+            "dialect_namespace": "https://interactiveadvertisingbureau.github.io/vast/vast4macros/vast4-macros-latest.html",
+            "dialect_revision": "git:e0858cd714474bf17ef61065097456d7643ff838",
+            "dialect_semantic": "CACHEBUSTING",
+            "mapping_status": "verified_universal",
+            "universal_semantic": "CACHEBUSTER",
+            "next_operation": "resolve_value",
+            "performed_by": "request_executor",
+            "encoding": { "kind": "iab_vast_uri", "depth": 1 }
+          }
+        },
+        {
+          "dialect": "iab_vast",
+          "dialect_namespace": "https://interactiveadvertisingbureau.github.io/vast/vast4macros/vast4-macros-latest.html",
+          "dialect_revision": "git:e0858cd714474bf17ef61065097456d7643ff838",
+          "dialect_semantic": "CACHEBUSTING",
+          "mapping_status": "verified_universal",
+          "universal_semantic": "CACHEBUSTER",
+          "operation": "resolve_value",
+          "performed_by": "request_executor",
+          "supported_contexts": ["url_query_value"],
+          "supported_encodings": [{ "kind": "iab_vast_uri", "depth": 1 }]
+        }
+      ],
+      "product_capabilities": [
+        {
+          "dialect": "adcp",
+          "dialect_semantic": "CACHEBUSTER",
+          "mapping_status": "verified_universal",
+          "universal_semantic": "CACHEBUSTER",
+          "operation": "translate_to_native",
+          "performed_by": "seller",
+          "supported_contexts": ["url_query_value"],
+          "translation_target": {
+            "token": "[CACHEBUSTING]",
+            "dialect": "iab_vast",
+            "dialect_namespace": "https://interactiveadvertisingbureau.github.io/vast/vast4macros/vast4-macros-latest.html",
+            "dialect_revision": "git:e0858cd714474bf17ef61065097456d7643ff838",
+            "dialect_semantic": "CACHEBUSTING",
+            "mapping_status": "verified_universal",
+            "universal_semantic": "CACHEBUSTER",
+            "next_operation": "resolve_value",
+            "performed_by": "request_executor",
+            "encoding": { "kind": "iab_vast_uri", "depth": 1 }
+          }
+        },
+        {
+          "dialect": "iab_vast",
+          "dialect_namespace": "https://interactiveadvertisingbureau.github.io/vast/vast4macros/vast4-macros-latest.html",
+          "dialect_revision": "git:e0858cd714474bf17ef61065097456d7643ff838",
+          "dialect_semantic": "CACHEBUSTING",
+          "mapping_status": "verified_universal",
+          "universal_semantic": "CACHEBUSTER",
+          "operation": "resolve_value",
+          "performed_by": "request_executor",
+          "supported_contexts": ["url_query_value"],
+          "supported_encodings": [{ "kind": "iab_vast_uri", "depth": 1 }]
+        }
+      ],
+      "expected": {
+        "status": "resolvable",
+        "reason": "capability_match",
+        "output": "https://video.acme-example.com/event?cb=[CACHEBUSTING]",
+        "emitted_declaration": {
+          "declaration_id": "cachebuster-translation",
+          "token": "[CACHEBUSTING]",
+          "dialect": "iab_vast",
+          "dialect_namespace": "https://interactiveadvertisingbureau.github.io/vast/vast4macros/vast4-macros-latest.html",
+          "dialect_revision": "git:e0858cd714474bf17ef61065097456d7643ff838",
+          "dialect_semantic": "CACHEBUSTING",
+          "mapping_status": "verified_universal",
+          "universal_semantic": "CACHEBUSTER",
+          "operation": "resolve_value",
+          "performed_by": "request_executor",
+          "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+          "encoding": { "kind": "iab_vast_uri", "depth": 1 },
+          "required": true,
+          "unavailable_behavior": "reject"
+        },
+        "final_output": "https://video.acme-example.com/event?cb=12345678"
+      }
+    },
+    {
+      "name": "nested click uses exactly two RFC 3986 passes",
+      "source": "https://track.acme-example.com/click?redirect=%%ACME_CLICK_ESC2%%",
+      "value": "https://brand.example/landing?item=one two",
+      "declaration": {
+        "declaration_id": "nested-click",
+        "token": "%%ACME_CLICK_ESC2%%",
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "CLICK_ESC2",
+        "mapping_status": "verified_universal",
+        "universal_semantic": "CLICK_URL",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+        "encoding": { "kind": "rfc3986", "depth": 2 },
+        "required": true,
+        "unavailable_behavior": "reject"
+      },
+      "seller_capabilities": [
+        {
+          "dialect": "vendor",
+          "dialect_namespace": "https://macros.acme-example.com/registry",
+          "dialect_revision": "mapping-v1",
+          "dialect_semantic": "CLICK_ESC2",
+          "mapping_status": "verified_universal",
+          "universal_semantic": "CLICK_URL",
+          "operation": "resolve_value",
+          "performed_by": "seller",
+          "supported_contexts": ["url_query_value"],
+          "supported_encodings": [{ "kind": "rfc3986", "depth": 2 }]
+        }
+      ],
+      "product_capabilities": [
+        {
+          "dialect": "vendor",
+          "dialect_namespace": "https://macros.acme-example.com/registry",
+          "dialect_revision": "mapping-v1",
+          "dialect_semantic": "CLICK_ESC2",
+          "mapping_status": "verified_universal",
+          "universal_semantic": "CLICK_URL",
+          "operation": "resolve_value",
+          "performed_by": "seller",
+          "supported_contexts": ["url_query_value"],
+          "supported_encodings": [{ "kind": "rfc3986", "depth": 2 }]
+        }
+      ],
+      "expected": {
+        "status": "resolvable",
+        "reason": "capability_match",
+        "output": "https://track.acme-example.com/click?redirect=https%253A%252F%252Fbrand.example%252Flanding%253Fitem%253Done%2520two"
+      }
+    },
+    {
+      "name": "maximum depth does not imply support for a different exact depth",
+      "source": "https://track.acme-example.com/click?redirect=%%ACME_CLICK_ESC2%%",
+      "value": "https://brand.example/",
+      "declaration": {
+        "declaration_id": "nested-click",
+        "token": "%%ACME_CLICK_ESC2%%",
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "CLICK_ESC2",
+        "mapping_status": "verified_universal",
+        "universal_semantic": "CLICK_URL",
+        "operation": "resolve_value",
+        "performed_by": "seller",
+        "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+        "encoding": { "kind": "rfc3986", "depth": 2 },
+        "required": true,
+        "unavailable_behavior": "reject"
+      },
+      "seller_capabilities": [
+        {
+          "dialect": "vendor",
+          "dialect_namespace": "https://macros.acme-example.com/registry",
+          "dialect_revision": "mapping-v1",
+          "dialect_semantic": "CLICK_ESC2",
+          "mapping_status": "verified_universal",
+          "universal_semantic": "CLICK_URL",
+          "operation": "resolve_value",
+          "performed_by": "seller",
+          "supported_contexts": ["url_query_value"],
+          "supported_encodings": [{ "kind": "rfc3986", "depth": 1 }]
+        }
+      ],
+      "product_capabilities": [
+        {
+          "dialect": "vendor",
+          "dialect_namespace": "https://macros.acme-example.com/registry",
+          "dialect_revision": "mapping-v1",
+          "dialect_semantic": "CLICK_ESC2",
+          "mapping_status": "verified_universal",
+          "universal_semantic": "CLICK_URL",
+          "operation": "resolve_value",
+          "performed_by": "seller",
+          "supported_contexts": ["url_query_value"],
+          "supported_encodings": [{ "kind": "rfc3986", "depth": 2 }]
+        }
+      ],
+      "expected": {
+        "status": "unsupported",
+        "reason": "encoding_unsupported",
+        "output": "https://track.acme-example.com/click?redirect=%%ACME_CLICK_ESC2%%"
+      }
+    },
+    {
+      "name": "request-executor ownership must match both capability layers",
+      "source": "https://video.acme-example.com/event?state=%%ACME_RENDER_STATE%%",
+      "declaration": {
+        "declaration_id": "player-state",
+        "token": "%%ACME_RENDER_STATE%%",
+        "dialect": "vendor",
+        "dialect_namespace": "https://macros.acme-example.com/registry",
+        "dialect_revision": "mapping-v1",
+        "dialect_semantic": "RENDER_STATE",
+        "mapping_status": "dialect_defined",
+        "operation": "resolve_value",
+        "performed_by": "request_executor",
+        "location": { "field": "url", "occurrence": 0, "context": "url_query_value" },
+        "encoding": { "kind": "rfc3986", "depth": 1 },
+        "required": true,
+        "unavailable_behavior": "reject"
+      },
+      "seller_capabilities": [
+        {
+          "dialect": "vendor",
+          "dialect_namespace": "https://macros.acme-example.com/registry",
+          "dialect_revision": "mapping-v1",
+          "dialect_semantic": "RENDER_STATE",
+          "mapping_status": "dialect_defined",
+          "operation": "resolve_value",
+          "performed_by": "request_executor",
+          "supported_contexts": ["url_query_value"],
+          "supported_encodings": [{ "kind": "rfc3986", "depth": 1 }]
+        }
+      ],
+      "product_capabilities": [
+        {
+          "dialect": "vendor",
+          "dialect_namespace": "https://macros.acme-example.com/registry",
+          "dialect_revision": "mapping-v1",
+          "dialect_semantic": "RENDER_STATE",
+          "mapping_status": "dialect_defined",
+          "operation": "resolve_value",
+          "performed_by": "seller",
+          "supported_contexts": ["url_query_value"],
+          "supported_encodings": [{ "kind": "rfc3986", "depth": 1 }]
+        }
+      ],
+      "expected": {
+        "status": "unsupported",
+        "reason": "resolver_mismatch",
+        "output": "https://video.acme-example.com/event?state=%%ACME_RENDER_STATE%%"
+      }
+    }
+  ]
+}
diff --git a/static/compliance/source/test-vectors/macro-processing.schema.json b/static/compliance/source/test-vectors/macro-processing.schema.json
new file mode 100644
index 0000000000..5364b90d11
--- /dev/null
+++ b/static/compliance/source/test-vectors/macro-processing.schema.json
@@ -0,0 +1,49 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "macro-processing.schema.json",
+  "title": "Creative macro processing vectors",
+  "type": "object",
+  "properties": {
+    "$schema": { "type": "string" },
+    "vectors": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": { "type": "string", "minLength": 1 },
+          "source": { "type": "string" },
+          "value": { "type": "string" },
+          "declaration": { "$ref": "/schemas/core/macro-declaration.json" },
+          "seller_capabilities": {
+            "type": "array",
+            "items": { "$ref": "/schemas/core/macro-resolution-capability.json" }
+          },
+          "product_capabilities": {
+            "type": "array",
+            "items": { "$ref": "/schemas/core/macro-resolution-capability.json" }
+          },
+          "expected": {
+            "type": "object",
+            "properties": {
+              "status": {
+                "type": "string",
+                "enum": ["resolvable", "preserved_for_downstream", "unsupported", "ambiguous"]
+              },
+              "reason": { "$ref": "/schemas/enums/macro-resolution-reason.json" },
+              "output": { "type": "string" },
+              "emitted_declaration": { "$ref": "/schemas/core/macro-declaration.json" },
+              "final_output": { "type": "string" }
+            },
+            "required": ["status", "reason", "output"],
+            "additionalProperties": false
+          }
+        },
+        "required": ["name", "source", "declaration", "seller_capabilities", "product_capabilities", "expected"],
+        "additionalProperties": false
+      }
+    }
+  },
+  "required": ["vectors"],
+  "additionalProperties": false
+}
diff --git a/static/compliance/source/universal/canonical-format-validate-input.yaml b/static/compliance/source/universal/canonical-format-validate-input.yaml
index 62051ec380..ab410bf422 100644
--- a/static/compliance/source/universal/canonical-format-validate-input.yaml
+++ b/static/compliance/source/universal/canonical-format-validate-input.yaml
@@ -261,6 +261,7 @@ phases:
                 asset_type: "vast"
                 delivery_type: "url"
                 url: "https://vast.acme.example/tag.xml"
+                vast_version: "4.0"
           targets:
             - kind: "canonical"
               id: "video_vast"
diff --git a/static/compliance/source/universal/ctv-experience-validate-input.yaml b/static/compliance/source/universal/ctv-experience-validate-input.yaml
index 3bc92194ee..9b85c8a41d 100644
--- a/static/compliance/source/universal/ctv-experience-validate-input.yaml
+++ b/static/compliance/source/universal/ctv-experience-validate-input.yaml
@@ -743,6 +743,7 @@ phases:
                 asset_type: "vast"
                 delivery_type: "url"
                 url: "https://vast.acmeoutdoor.example/overlay.xml"
+                vast_version: "4.2"
                 duration_ms: 20000
           targets:
             - kind: "product"
@@ -832,6 +833,7 @@ phases:
                 asset_type: "vast"
                 delivery_type: "url"
                 url: "https://vast.acmeoutdoor.example/menu-invalid.xml"
+                vast_version: "4.2"
           targets:
             - kind: "product"
               id: "ctv_invalid_menu_video_vast"
@@ -921,6 +923,7 @@ phases:
                 asset_type: "vast"
                 delivery_type: "url"
                 url: "https://vast.acmeoutdoor.example/overlay-linear-invalid.xml"
+                vast_version: "4.2"
                 duration_ms: 20000
           targets:
             - kind: "product"
@@ -964,6 +967,7 @@ phases:
                 asset_type: "vast"
                 delivery_type: "url"
                 url: "https://vast.acmeoutdoor.example/overlay-short-invalid.xml"
+                vast_version: "4.2"
           targets:
             - kind: "product"
               id: "ctv_invalid_overlay_short_duration"
@@ -1006,6 +1010,7 @@ phases:
                 asset_type: "vast"
                 delivery_type: "url"
                 url: "https://vast.acmeoutdoor.example/in-scene-invalid.xml"
+                vast_version: "4.2"
                 duration_ms: 5000
           targets:
             - kind: "product"
diff --git a/static/schemas/source/core/assets/asset-union.json b/static/schemas/source/core/assets/asset-union.json
index 5bf62fb6bc..635bfcb360 100644
--- a/static/schemas/source/core/assets/asset-union.json
+++ b/static/schemas/source/core/assets/asset-union.json
@@ -9,6 +9,7 @@
     { "$ref": "/schemas/core/assets/video-asset.json" },
     { "$ref": "/schemas/core/assets/audio-asset.json" },
     { "$ref": "/schemas/core/assets/vast-asset.json" },
+    { "$ref": "/schemas/core/assets/display-tag-asset.json" },
     { "$ref": "/schemas/core/assets/text-asset.json" },
     { "$ref": "/schemas/core/assets/url-asset.json" },
     { "$ref": "/schemas/core/assets/html-asset.json" },
diff --git a/static/schemas/source/core/assets/daast-asset.json b/static/schemas/source/core/assets/daast-asset.json
index c047acde84..957bbafc1c 100644
--- a/static/schemas/source/core/assets/daast-asset.json
+++ b/static/schemas/source/core/assets/daast-asset.json
@@ -39,6 +39,12 @@
     "provenance": {
       "$ref": "/schemas/core/provenance.json",
       "description": "Provenance metadata for this asset, overrides manifest-level provenance"
+    },
+    "macro_declarations": {
+      "type": "array",
+      "items": { "$ref": "/schemas/core/macro-declaration.json" },
+      "minItems": 1,
+      "description": "One declaration per occurrence in a field carried by this asset. URL-delivered assets declare only locator-URL occurrences; receivers do not infer declarations for tokens discovered later in a fetched document."
     }
   },
   "required": [
@@ -53,9 +59,11 @@
           "description": "Discriminator indicating DAAST is delivered via URL endpoint"
         },
         "url": {
-          "type": "string",
-          "format": "uri-template",
-          "description": "URL endpoint that returns DAAST XML. May carry unsubstituted ad-server macros — DAAST/VAST-style `[MACRO]` and `${MACRO}` placeholders are accepted as-is (RFC 6570 syntax); buyers MUST NOT pre-encode macro delimiters, since players match the literal token at substitution time."
+          "$ref": "/schemas/core/macro-bearing-url.json",
+          "description": "URL endpoint returning DAAST XML. Macro delimiters remain byte-preserved and are processed only under attached occurrence declarations."
+        },
+        "macro_declarations": {
+          "items": { "properties": { "location": { "properties": { "field": { "const": "url" } } } } }
         }
       },
       "required": [
@@ -73,6 +81,9 @@
         "content": {
           "type": "string",
           "description": "Inline DAAST XML content"
+        },
+        "macro_declarations": {
+          "items": { "properties": { "location": { "properties": { "field": { "const": "content" } } } } }
         }
       },
       "required": [
diff --git a/static/schemas/source/core/assets/daast-tracker-asset.json b/static/schemas/source/core/assets/daast-tracker-asset.json
index 9dfdc10234..f13fa79fb5 100644
--- a/static/schemas/source/core/assets/daast-tracker-asset.json
+++ b/static/schemas/source/core/assets/daast-tracker-asset.json
@@ -34,9 +34,19 @@
       "description": "The DAAST tracking event this URL fires on. MUST NOT be `impression` (model as `url` asset with `url_type: \"tracker_pixel\"`), `clickTracking` / `customClick` (click-tracking trackers go on their own URL asset), `error`, or any of the `ViewableImpression`-element children (`viewable`, `notViewable`, `viewUndetermined`, `measurableImpression`, `viewableImpression`)."
     },
     "url": {
-      "type": "string",
-      "format": "uri-template",
-      "description": "Tracker URL that fires when `daast_event` occurs. May carry AdCP universal macros; the sales agent or ad server URL-encodes substituted values at serve time. See docs/creative/universal-macros.mdx."
+      "$ref": "/schemas/core/macro-bearing-url.json",
+      "description": "Tracker URL fired for the DAAST event. Attached declarations identify each macro occurrence, processing actor, and exact encoding profile."
+    },
+    "macro_declarations": {
+      "type": "array",
+      "items": {
+        "allOf": [
+          { "$ref": "/schemas/core/macro-declaration.json" },
+          { "properties": { "location": { "properties": { "field": { "const": "url" } } } } }
+        ]
+      },
+      "minItems": 1,
+      "description": "Exact tokens in `url` and their resolver/encoding contracts."
     },
     "offset": {
       "type": "string",
diff --git a/static/schemas/source/core/assets/display-tag-asset.json b/static/schemas/source/core/assets/display-tag-asset.json
new file mode 100644
index 0000000000..cfc4670cc8
--- /dev/null
+++ b/static/schemas/source/core/assets/display-tag-asset.json
@@ -0,0 +1,132 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/assets/display-tag-asset.json",
+  "title": "Display Tag Asset",
+  "description": "One atomic third-party display delivery representation. `delivery_type` distinguishes a single ad-request URL, byte-preserved inline markup, and a paired redirect whose ad-request and click-through URLs MUST travel together. This is not an HTML5 bundle: seller-hosted HTML5 zip files use `asset_type: \"zip\"` under `format_kind: \"html5\"`.",
+  "type": "object",
+  "properties": {
+    "asset_type": {
+      "type": "string",
+      "const": "display_tag",
+      "description": "Discriminator identifying an atomic third-party display-tag representation."
+    },
+    "macro_declarations": {
+      "type": "array",
+      "items": { "$ref": "/schemas/core/macro-declaration.json" },
+      "minItems": 1,
+      "description": "Exact macro tokens present anywhere in this representation. Tokens remain byte-preserved until the resolver named by each declaration substitutes them."
+    },
+    "provenance": {
+      "$ref": "/schemas/core/provenance.json",
+      "description": "Provenance metadata for this asset, overriding manifest-level provenance."
+    }
+  },
+  "required": ["asset_type"],
+  "discriminator": { "propertyName": "delivery_type" },
+  "oneOf": [
+    {
+      "title": "Tag URL",
+      "type": "object",
+      "properties": {
+        "asset_type": { "type": "string", "const": "display_tag" },
+        "macro_declarations": {
+          "type": "array",
+          "items": {
+            "allOf": [
+              { "$ref": "/schemas/core/macro-declaration.json" },
+              { "properties": { "location": { "properties": { "field": { "const": "url" } } } } }
+            ]
+          },
+          "minItems": 1
+        },
+        "provenance": { "$ref": "/schemas/core/provenance.json" },
+        "delivery_type": { "type": "string", "const": "tag_url" },
+        "url": {
+          "$ref": "/schemas/core/macro-bearing-url.json",
+          "description": "Ad-request URL invoked at impression time. It is equivalent to the backward-compatible `url` asset with `url_type: \"ad_request\"`."
+        }
+      },
+      "required": ["asset_type", "delivery_type", "url"],
+      "not": {
+        "anyOf": [
+          { "required": ["markup"] },
+          { "required": ["ad_request_url"] },
+          { "required": ["clickthrough_url"] }
+        ]
+      }
+    },
+    {
+      "title": "Inline markup",
+      "type": "object",
+      "properties": {
+        "asset_type": { "type": "string", "const": "display_tag" },
+        "macro_declarations": {
+          "type": "array",
+          "items": {
+            "allOf": [
+              { "$ref": "/schemas/core/macro-declaration.json" },
+              { "properties": { "location": { "properties": { "field": { "const": "markup" } } } } }
+            ]
+          },
+          "minItems": 1
+        },
+        "provenance": { "$ref": "/schemas/core/provenance.json" },
+        "delivery_type": { "type": "string", "const": "inline_markup" },
+        "markup_type": {
+          "type": "string",
+          "enum": ["iframe_javascript", "javascript", "standard"],
+          "description": "How the destination traffics the byte-preserved markup."
+        },
+        "markup": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 1048576,
+          "description": "Exact third-party tag markup. Receivers MUST preserve its bytes and MUST NOT reinterpret it as a seller-hosted HTML5 bundle."
+        }
+      },
+      "required": ["asset_type", "delivery_type", "markup_type", "markup"],
+      "not": {
+        "anyOf": [
+          { "required": ["url"] },
+          { "required": ["ad_request_url"] },
+          { "required": ["clickthrough_url"] }
+        ]
+      }
+    },
+    {
+      "title": "Paired redirect",
+      "type": "object",
+      "properties": {
+        "asset_type": { "type": "string", "const": "display_tag" },
+        "macro_declarations": {
+          "type": "array",
+          "items": {
+            "allOf": [
+              { "$ref": "/schemas/core/macro-declaration.json" },
+              { "properties": { "location": { "properties": { "field": { "enum": ["ad_request_url", "clickthrough_url"] } } } } }
+            ]
+          },
+          "minItems": 1
+        },
+        "provenance": { "$ref": "/schemas/core/provenance.json" },
+        "delivery_type": { "type": "string", "const": "paired_redirect" },
+        "ad_request_url": {
+          "$ref": "/schemas/core/macro-bearing-url.json",
+          "description": "Image or ad-request URL entered into the destination ad server. This field deliberately accepts byte-preserved vendor tokens that are not RFC 6570 URI templates."
+        },
+        "clickthrough_url": {
+          "$ref": "/schemas/core/macro-bearing-url.json",
+          "description": "Click-through URL paired with `ad_request_url`. This field deliberately accepts byte-preserved vendor tokens that are not RFC 6570 URI templates. The pair MUST NOT be split, mixed, or revised independently."
+        }
+      },
+      "required": ["asset_type", "delivery_type", "ad_request_url", "clickthrough_url"],
+      "not": {
+        "anyOf": [
+          { "required": ["url"] },
+          { "required": ["markup"] }
+        ]
+      }
+    }
+  ],
+  "additionalProperties": true
+}
diff --git a/static/schemas/source/core/assets/html-asset.json b/static/schemas/source/core/assets/html-asset.json
index 76b89e6f4a..267c80ac8f 100644
--- a/static/schemas/source/core/assets/html-asset.json
+++ b/static/schemas/source/core/assets/html-asset.json
@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "/schemas/core/assets/html-asset.json",
   "title": "HTML Asset",
-  "description": "Inline HTML content asset. For URL-delivered HTML5 banner bundles, use the zip asset type instead. For single-URL iframe-rendered tag references, use the url asset type with an appropriate url_type.",
+  "description": "Inline HTML content asset. For seller-hosted HTML5 banner bundles, use the zip asset type. For third-party display markup or paired redirects, use the display_tag asset so the trafficking representation remains explicit.",
   "type": "object",
   "properties": {
     "asset_type": {
diff --git a/static/schemas/source/core/assets/javascript-asset.json b/static/schemas/source/core/assets/javascript-asset.json
index 9b1522c7ad..d5bd1dcc3c 100644
--- a/static/schemas/source/core/assets/javascript-asset.json
+++ b/static/schemas/source/core/assets/javascript-asset.json
@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "/schemas/core/assets/javascript-asset.json",
   "title": "JavaScript Asset",
-  "description": "Inline JavaScript content asset. For URL-delivered third-party tag scripts, use the url asset type with url_type 'tracker_script'. For HTML5 banner bundles that include JavaScript, use the zip asset type.",
+  "description": "Inline JavaScript content asset. For third-party display ad markup, use the display_tag asset with delivery_type `inline_markup`; for measurement scripts use a typed tracker; for seller-hosted HTML5 bundles use zip.",
   "type": "object",
   "properties": {
     "asset_type": {
diff --git a/static/schemas/source/core/assets/pixel-tracker-asset.json b/static/schemas/source/core/assets/pixel-tracker-asset.json
index 48b4fc0f6e..2c1b78c41d 100644
--- a/static/schemas/source/core/assets/pixel-tracker-asset.json
+++ b/static/schemas/source/core/assets/pixel-tracker-asset.json
@@ -30,9 +30,19 @@
       "description": "How the tracker URL is invoked at serve time:\n- `img` — fired as an image pixel (HTTP GET with `<img>`-like semantics; no JS execution)\n- `js` — fired as a script include (renderer evaluates the URL's response as JavaScript)\n\nMatches IAB OpenRTB Native 1.2 method enum (1=img, 2=js). `js` MUST only be used by sellers whose renderer supports JavaScript trackers; sellers without JS-tracker support MUST reject `method: js` declarations at sync_creatives time with `CREATIVE_REJECTED` carrying the reason."
     },
     "url": {
-      "type": "string",
-      "format": "uri-template",
-      "description": "Tracker URL fired when `event` occurs. May carry AdCP universal macros (e.g., `{MEDIA_BUY_ID}`, `{CREATIVE_ID}`, `{CACHEBUSTER}`); the seller's renderer URL-encodes substituted values at serve time. See docs/creative/universal-macros.mdx."
+      "$ref": "/schemas/core/macro-bearing-url.json",
+      "description": "Tracker URL fired when `event` occurs. Macro processing and encoding follow an attached occurrence declaration; absent declarations retain the legacy universal-macro path."
+    },
+    "macro_declarations": {
+      "type": "array",
+      "items": {
+        "allOf": [
+          { "$ref": "/schemas/core/macro-declaration.json" },
+          { "properties": { "location": { "properties": { "field": { "const": "url" } } } } }
+        ]
+      },
+      "minItems": 1,
+      "description": "One declaration per token occurrence in `url`; declaration_id values MUST be unique and locations MUST resolve. When omitted, legacy behavior applies."
     },
     "custom_event_name": {
       "type": "string",
diff --git a/static/schemas/source/core/assets/url-asset.json b/static/schemas/source/core/assets/url-asset.json
index 652f1d6022..e75ee91e67 100644
--- a/static/schemas/source/core/assets/url-asset.json
+++ b/static/schemas/source/core/assets/url-asset.json
@@ -3,7 +3,7 @@
   "$id": "/schemas/core/assets/url-asset.json",
   "title": "URL Asset",
   "$comment": "Fallback table is also rendered in docs/creative/asset-types.mdx (URL Asset section). Keep the two in sync — schema description is the normative source for conformance tools; mdx is the human-readable copy.",
-  "description": "URL reference asset. `url_type` declares the mechanism a receiver uses to invoke the URL (clickthrough vs. tracker_pixel vs. tracker_script) and is distinct from the URL's purpose, which the format declares in `url-asset-requirements.role` (clickthrough, landing_page, impression_tracker, click_tracker, viewability_tracker, third_party_tracker). Senders SHOULD include `url_type` on every URL asset. When `url_type` is absent, receivers SHOULD fall back to the format's `url-asset-requirements.role` per this mapping: clickthrough/landing_page → `clickthrough`; impression_tracker/click_tracker → `tracker_pixel`; viewability_tracker → `tracker_script` (OMID and equivalent verification SDKs require a <script> tag — firing them as a pixel produces no measurement); third_party_tracker → no safe fallback (mechanism is integration-specific — DV/IAS ship both pixel and script forms — receivers MAY reject or warn). When neither `url_type` nor a format-side `role` is available, receivers MUST NOT silently pick a mechanism; they SHOULD reject the manifest. Note: VAST/DAAST tag URLs are not URL assets — use `asset_type: \"vast\"` (or the dedicated tracker types pending RFC #2915), not `asset_type: \"url\"` with a tracker_pixel mechanism.",
+  "description": "URL reference asset. `url_type` declares the mechanism a receiver uses to invoke the URL (`clickthrough`, display `ad_request`, `tracker_pixel`, or `tracker_script`) and is distinct from the URL's purpose, which the format declares in `url-asset-requirements.role`. Senders SHOULD include `url_type` on every URL asset. When `url_type` is absent, receivers SHOULD fall back to the format's role: clickthrough/landing_page → `clickthrough`; impression_tracker/click_tracker → `tracker_pixel`; viewability_tracker → `tracker_script`; third_party_tracker and display ad requests have no safe fallback. When neither `url_type` nor a format-side role is available, receivers MUST NOT silently pick a mechanism. VAST/DAAST tag URLs are not URL assets — use `asset_type: \"vast\"` or `asset_type: \"daast\"`.",
   "type": "object",
   "properties": {
     "asset_type": {
@@ -12,13 +12,23 @@
       "description": "Discriminator identifying this as a URL asset. See /schemas/creative/asset-types for the registry."
     },
     "url": {
-      "type": "string",
-      "format": "uri-template",
-      "description": "URL reference. May be a plain URI or an RFC 6570 URI template carrying AdCP universal macros (e.g., `{SKU}`, `{MEDIA_BUY_ID}`). Buyers MUST NOT pre-encode macro braces at sync time; the ad server URL-encodes substituted values at impression time. See docs/creative/universal-macros.mdx."
+      "$ref": "/schemas/core/macro-bearing-url.json",
+      "description": "URL reference carrying plain, AdCP, IAB, or declared vendor macro syntax. Buyers preserve token delimiters; the authoritative declaration determines the processing operation and encoding."
     },
     "url_type": {
       "$ref": "/schemas/enums/url-asset-type.json",
-      "description": "Mechanism a receiver uses to invoke this URL (distinct from purpose, which lives in `url-asset-requirements.role`): `clickthrough` for user click destination (landing page), `tracker_pixel` for impression/event tracking via HTTP request (fires GET, expects pixel/204 response), `tracker_script` for measurement SDKs that must load as a <script> tag (OMID verification, native event trackers using method:2). SHOULD be present on every URL asset; senders that omit it force the receiver into the role-based fallback described in this schema's top-level description."
+      "description": "Mechanism a receiver uses to invoke this URL: `clickthrough` for a user destination, `ad_request` for a third-party display creative request, `tracker_pixel` for an event HTTP request, or `tracker_script` for a script include. SHOULD be present on every URL asset."
+    },
+    "macro_declarations": {
+      "type": "array",
+      "items": {
+        "allOf": [
+          { "$ref": "/schemas/core/macro-declaration.json" },
+          { "properties": { "location": { "properties": { "field": { "const": "url" } } } } }
+        ]
+      },
+      "minItems": 1,
+      "description": "One declaration per token occurrence in `url`; declaration_id values MUST be unique and every location MUST identify an existing occurrence. Absence retains legacy opaque transport behavior."
     },
     "description": {
       "type": "string",
diff --git a/static/schemas/source/core/assets/vast-asset.json b/static/schemas/source/core/assets/vast-asset.json
index 244469b27f..dad68ed147 100644
--- a/static/schemas/source/core/assets/vast-asset.json
+++ b/static/schemas/source/core/assets/vast-asset.json
@@ -12,7 +12,13 @@
     },
     "vast_version": {
       "$ref": "/schemas/enums/vast-version.json",
-      "description": "VAST specification version"
+      "description": "Exact VAST version declared by the supplied URL response or inline document. Required by the 3.2 canonical `video_vast` manifest path; optional only on the deprecated named-format compatibility path. Receivers MUST NOT relabel or synthesize a newer version merely because the destination accepts it."
+    },
+    "macro_declarations": {
+      "type": "array",
+      "items": { "$ref": "/schemas/core/macro-declaration.json" },
+      "minItems": 1,
+      "description": "One declaration per exact occurrence in a field carried by this asset. A URL-delivered asset can declare only occurrences in its locator `url`; tokens discovered later in a fetched VAST response require document validation evidence or an inline/snapshotted asset and MUST NOT be guessed from the locator. IAB tokens cite a registry namespace and revision rather than copying the live registry into AdCP."
     },
     "vpaid_enabled": {
       "type": "boolean",
@@ -59,9 +65,11 @@
           "description": "Discriminator indicating VAST is delivered via URL endpoint"
         },
         "url": {
-          "type": "string",
-          "format": "uri-template",
-          "description": "URL endpoint that returns VAST XML. May carry unsubstituted ad-server macros — VAST-style `[MACRO]` and `${MACRO}` placeholders are accepted as-is (RFC 6570 syntax); buyers MUST NOT pre-encode macro delimiters, since players match the literal token at substitution time."
+          "$ref": "/schemas/core/macro-bearing-url.json",
+          "description": "URL endpoint returning VAST XML. Macro delimiters remain byte-preserved; declarations distinguish occurrences in this locator URL from occurrences in inline or fetched VAST content."
+        },
+        "macro_declarations": {
+          "items": { "properties": { "location": { "properties": { "field": { "const": "url" } } } } }
         }
       },
       "required": [
@@ -79,6 +87,9 @@
         "content": {
           "type": "string",
           "description": "Inline VAST XML content"
+        },
+        "macro_declarations": {
+          "items": { "properties": { "location": { "properties": { "field": { "const": "content" } } } } }
         }
       },
       "required": [
diff --git a/static/schemas/source/core/assets/vast-tracker-asset.json b/static/schemas/source/core/assets/vast-tracker-asset.json
index 9996264e55..0efec7cc37 100644
--- a/static/schemas/source/core/assets/vast-tracker-asset.json
+++ b/static/schemas/source/core/assets/vast-tracker-asset.json
@@ -34,9 +34,19 @@
       "description": "The VAST tracking event this URL fires on. Maps 1:1 to the VAST `Tracking event=\"...\"` attribute inside `TrackingEvents`. MUST NOT be `impression` (belongs in the VAST `Impression` element — model as a `url` asset with `url_type: \"tracker_pixel\"`), `clickTracking` / `customClick` (belong in `VideoClicks`), `error` (VAST `Error` element), or any of `viewable` / `notViewable` / `viewUndetermined` / `measurableImpression` / `viewableImpression` (children of the VAST `ViewableImpression` element, not `TrackingEvents`)."
     },
     "url": {
-      "type": "string",
-      "format": "uri-template",
-      "description": "Tracker URL that fires when `vast_event` occurs. May carry AdCP universal macros (e.g., `{SKU}`, `{MEDIA_BUY_ID}`); the sales agent or ad server URL-encodes substituted values at serve time. See docs/creative/universal-macros.mdx."
+      "$ref": "/schemas/core/macro-bearing-url.json",
+      "description": "Tracker URL fired for the VAST event. Attached declarations identify each macro occurrence, registry revision, processing actor, and exact encoding profile."
+    },
+    "macro_declarations": {
+      "type": "array",
+      "items": {
+        "allOf": [
+          { "$ref": "/schemas/core/macro-declaration.json" },
+          { "properties": { "location": { "properties": { "field": { "const": "url" } } } } }
+        ]
+      },
+      "minItems": 1,
+      "description": "Exact tokens in `url` and their resolver/encoding contracts."
     },
     "offset": {
       "type": "string",
diff --git a/static/schemas/source/core/canonical-format-option.json b/static/schemas/source/core/canonical-format-option.json
index ef35835d65..47178bf7c5 100644
--- a/static/schemas/source/core/canonical-format-option.json
+++ b/static/schemas/source/core/canonical-format-option.json
@@ -2,11 +2,26 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "/schemas/core/canonical-format-option.json",
   "title": "Canonical Format Option",
-  "description": "Compact canonical creative-format declaration. Legacy named-format links are intentionally absent; params are validated against the canonical schema selected by format_kind without inlining every format union into product discovery.",
+  "description": "Compact canonical creative-format declaration. Legacy named-format links are intentionally absent; params are validated against the canonical schema selected by format_kind without inlining every format union into product discovery. Format-option processing metadata such as macro_resolution_capabilities stays at this object's top level and is not part of canonical params.",
   "type": "object",
   "properties": {
     "format_option_id": { "type": "string", "minLength": 1 },
     "publisher_domain": { "type": "string", "pattern": "^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$" },
+    "macro_resolution_capabilities": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "/schemas/core/macro-resolution-capability.json" },
+      "description": "Binding format-option processing capabilities for exact macro dialect identities, semantics, operations, actors, contexts, and encodings. Absence means undeclared, not supported on the opt-in declared-token path. Seller-wide capabilities are only a ceiling. This field does not claim that a buyer tracker asset is honored or fired.",
+      "x-adcp-validation": {
+        "verifier_constraints": {
+          "translation_chain_closure": "every translate_to_native entry must have an exact matching resolve_value entry for its translation_target in this same array"
+        }
+      }
+    },
+    "technical_requirements_complete": {
+      "type": "boolean",
+      "description": "When true, every technical creative-acceptance constraint for this declaration layer is expressed and omitted technical fields mean no constraint. When false or absent, omitted technical fields are undeclared and MUST NOT be inferred. The effective contract is complete only when every applicable declaration layer asserts true."
+    },
     "display_name": { "type": "string", "minLength": 1 },
     "sample_render_url": { "type": "string", "format": "uri", "pattern": "^https://" },
     "applies_to_channels": {
diff --git a/static/schemas/source/core/creative-asset.json b/static/schemas/source/core/creative-asset.json
index b5a3c760b5..adad3f2252 100644
--- a/static/schemas/source/core/creative-asset.json
+++ b/static/schemas/source/core/creative-asset.json
@@ -27,6 +27,10 @@
       "$ref": "/schemas/core/format-option-ref.json",
       "description": "3.1+ format-option path, optional. Structured format option reference matching one of the target product's `format_options[]` declarations. Publisher-catalog-backed options match by `{ scope: \"publisher\", publisher_domain, format_option_id }`; product-local options match by `{ scope: \"product\", format_option_id }`. Required when the target product has multiple `format_options` entries sharing the same `format_kind`; optional when `format_kind` alone routes the creative to a single declaration. Product-scoped refs require an enclosing target product/package context."
     },
+    "representation_selection": {
+      "$ref": "/schemas/core/representation-selection.json",
+      "description": "Readback lineage to the complete CreativeRepresentationSet revision and representation selected before this seller-bound creative was synced."
+    },
     "assets": {
       "type": "object",
       "description": "Assets required by the format, keyed by asset_id or canonical asset_group_id. Each slot value is either a single asset object or an array of asset objects (for slots with `min`/`max > 1` like carousel `cards` or responsive_creative `headlines`). Each asset value carries an `asset_type` discriminator that selects the matching asset schema, including reference assets such as `published_post` when a product accepts already-published post references.",
@@ -144,16 +148,6 @@
       { "required": ["capability_ref"] }
     ]
   },
-  "allOf": [
-    {
-      "if": {
-        "properties": { "format_kind": { "const": "coordinated_placements" } },
-        "required": ["format_kind"]
-      },
-      "then": { "required": ["component_assets"] },
-      "else": { "not": { "required": ["component_assets"] } }
-    }
-  ],
   "oneOf": [
     {
       "title": "v1 creative (named-format reference)",
@@ -169,5 +163,15 @@
       "not": { "required": ["format_id"] }
     }
   ],
+  "allOf": [
+    {
+      "if": {
+        "properties": { "format_kind": { "const": "coordinated_placements" } },
+        "required": ["format_kind"]
+      },
+      "then": { "required": ["component_assets"] },
+      "else": { "not": { "required": ["component_assets"] } }
+    }
+  ],
   "additionalProperties": true
 }
diff --git a/static/schemas/source/core/creative-localization.json b/static/schemas/source/core/creative-localization.json
index 5db747333f..850e40cdbc 100644
--- a/static/schemas/source/core/creative-localization.json
+++ b/static/schemas/source/core/creative-localization.json
@@ -45,7 +45,7 @@
           "type": "string",
           "minLength": 1,
           "maxLength": 255,
-          "description": "Buyer-assigned stable identity for the source locale variant. This is a separate namespace from build_variant_id and served delivery variant_id.",
+          "description": "Buyer-assigned stable identity for the source locale variant. This is a separate namespace from build_variant_id and the served execution variant_id.",
           "x-entity": "creative_locale_variant"
         },
         "locale": {
diff --git a/static/schemas/source/core/creative-manifest.json b/static/schemas/source/core/creative-manifest.json
index acaf0c10db..fa2f8b8130 100644
--- a/static/schemas/source/core/creative-manifest.json
+++ b/static/schemas/source/core/creative-manifest.json
@@ -18,6 +18,10 @@
       "$ref": "/schemas/core/format-option-ref.json",
       "description": "3.1+ format-option path, optional. Structured format option reference matching one of the target product's `format_options[]` declarations. Publisher-catalog-backed options match by `{ scope: \"publisher\", publisher_domain, format_option_id }`; product-local options match by `{ scope: \"product\", format_option_id }`. Required when the target product carries multiple `format_options` entries sharing the same `format_kind`; optional when `format_kind` alone routes the manifest to a single declaration. Product-scoped refs require an enclosing target product/package context."
     },
+    "representation_selection": {
+      "$ref": "/schemas/core/representation-selection.json",
+      "description": "Present when this seller-bound manifest was selected from a CreativeRepresentationSet. Preserves creative, complete revision digest, and selected representation lineage through sync and reporting."
+    },
     "assets": {
       "type": "object",
       "description": "Map of slot keys to actual asset content. Legacy named-format path: each key matches an `asset_id` from the format's `assets` array (e.g., 'banner_image', 'clickthrough_url', 'video_file', 'vast_tag'). 3.1+ canonical-format path: each key matches an `asset_group_id` from the format's `slots` declaration drawn from the canonical vocabulary registry (e.g., 'images_landscape', 'video', 'published_post', 'landing_page_url', 'vast_tag', 'script', 'creative_brief'). Either path produces the same envelope shape; only the slot-key vocabulary differs.\n\nEach slot value is **either** a single asset object (most slots — image, video, published_post, vast_tag, landing_page_url, etc.) **or** an array of asset objects (slots with `min`/`max` counts on the format declaration — `cards` on `image_carousel`, `headlines` / `descriptions` / `images_landscape` on `responsive_creative`, etc.). Single-vs-array shape is governed by the format's `slots[].min` and `slots[].max` parameters: when `max > 1` (or when the slot is conceptually a pool), the value MUST be an array; when the slot is single-valued, the value MUST be a single object. Each asset value (single or array element) carries an `asset_type` discriminator (image, video, audio, vast, daast, text, markdown, url, html, css, webhook, javascript, brief, catalog, published_post, zip, card) that selects the matching asset schema. Validators with OpenAPI-style discriminator support use `asset_type` to report errors against only the selected branch instead of all branches.",
@@ -73,16 +77,6 @@
   "required": [
     "assets"
   ],
-  "allOf": [
-    {
-      "if": {
-        "properties": { "format_kind": { "const": "coordinated_placements" } },
-        "required": ["format_kind"]
-      },
-      "then": { "required": ["component_assets"] },
-      "else": { "not": { "required": ["component_assets"] } }
-    }
-  ],
   "not": {
     "anyOf": [
       { "required": ["capability_id"] },
@@ -104,5 +98,15 @@
       "not": { "required": ["format_id"] }
     }
   ],
+  "allOf": [
+    {
+      "if": {
+        "properties": { "format_kind": { "const": "coordinated_placements" } },
+        "required": ["format_kind"]
+      },
+      "then": { "required": ["component_assets"] },
+      "else": { "not": { "required": ["component_assets"] } }
+    }
+  ],
   "additionalProperties": true
 }
diff --git a/static/schemas/source/core/creative-representation-set.json b/static/schemas/source/core/creative-representation-set.json
new file mode 100644
index 0000000000..e6efd866aa
--- /dev/null
+++ b/static/schemas/source/core/creative-representation-set.json
@@ -0,0 +1,56 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/creative-representation-set.json",
+  "title": "Creative Representation Set",
+  "description": "A complete buyer-authored revision containing one or more equivalent trafficking representations before seller binding. Exactly one compatible representation is selected for each seller-bound manifest. Representations are not rotation, A/B content, build variants, locale variants, or served variants.",
+  "x-adcp-validation": {
+    "verifier_constraints": {
+      "revision_identity": {
+        "scope": ["creative_id", "revision_id"],
+        "complete_preimage": "the complete CreativeRepresentationSet, never only the selected representation",
+        "canonical_content": "RFC 8785 JCS after removing exactly the top-level $schema, creative_id, revision_id, revision_content_digest, and name properties",
+        "unknown_fields": "included",
+        "array_order": "significant",
+        "duplicate_json_members": "reject before canonicalization",
+        "digest": "revision_content_digest MUST equal lowercase-hex SHA-256 of the canonical content",
+        "immutability": "reusing creative_id plus revision_id with a different digest or canonical content MUST fail with CREATIVE_REVISION_CONTENT_MISMATCH",
+        "equivalence_assertion": "the buyer asserts that all representations are equivalent; the digest proves set integrity, not semantic or rendered equivalence"
+      }
+    },
+    "spec": "docs/creative/representation-sets.mdx#revision-identity"
+  },
+  "type": "object",
+  "properties": {
+    "creative_id": {
+      "type": "string",
+      "minLength": 1,
+      "x-entity": "creative",
+      "description": "Stable logical creative identifier across all representations and later seller-bound manifests."
+    },
+    "revision_id": {
+      "$ref": "/schemas/core/creative-revision-id.json",
+      "description": "Buyer-assigned immutable revision identity for this complete representation set. Changing any revision-bearing part of the set requires a new revision_id; selection does not."
+    },
+    "revision_content_digest": {
+      "type": "string",
+      "pattern": "^sha256:[a-f0-9]{64}$",
+      "description": "SHA-256 of the RFC 8785 JCS canonical revision content defined by this schema. The producer computes it over the complete representation set after removing exactly the top-level $schema, creative_id, revision_id, revision_content_digest, and name properties. `$schema` is transport/schema-location metadata and never mints creative content identity. Resolvers MUST recompute and reject a mismatch; selection readback carries the verified digest so downstream sellers bind the revision to the complete source set rather than only the selected manifest."
+    },
+    "name": { "type": "string", "minLength": 1 },
+    "representations": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "/schemas/core/creative-representation.json" },
+      "x-adcp-validation": {
+        "unique_item_properties": ["representation_id"]
+      },
+      "description": "Complete ordered set of equivalent representations. `representation_id` values MUST be unique within this array. Unsupported entries remain byte-for-byte unchanged; neither filtering nor selection changes this revision's canonical content."
+    },
+    "provenance": {
+      "$ref": "/schemas/core/provenance.json",
+      "description": "Default provenance for every retained representation and for the selected seller-bound output unless a representation supplies a narrower provenance object."
+    }
+  },
+  "required": ["creative_id", "revision_id", "revision_content_digest", "name", "representations"],
+  "additionalProperties": true
+}
diff --git a/static/schemas/source/core/creative-representation.json b/static/schemas/source/core/creative-representation.json
new file mode 100644
index 0000000000..53750ba5e6
--- /dev/null
+++ b/static/schemas/source/core/creative-representation.json
@@ -0,0 +1,92 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/creative-representation.json",
+  "title": "Creative Representation",
+  "description": "One equivalent trafficking representation retained within a CreativeRepresentationSet before seller binding. `representation_id` is stable within its parent revision and identifies a representation, not rotation, A/B content, build output, locale, or a seller's served execution variant.",
+  "allOf": [
+    { "$ref": "/schemas/core/creative-manifest.json" },
+    {
+      "required": ["format_kind"],
+      "not": {
+        "anyOf": [
+          { "required": ["format_id"] },
+          { "required": ["format_option_ref"] },
+          { "required": ["representation_selection"] }
+        ]
+      }
+    },
+    {
+      "$comment": "The opt-in late-bound VAST representation path requires one exact asset version. Ordinary legacy/canonical CreativeManifest and CreativeAsset payloads retain additive 3.x compatibility.",
+      "if": {
+        "properties": { "format_kind": { "const": "video_vast" } },
+        "required": ["format_kind"]
+      },
+      "then": {
+        "properties": {
+          "assets": {
+            "patternProperties": {
+              ".*": {
+                "allOf": [
+                  {
+                    "if": {
+                      "type": "object",
+                      "properties": { "asset_type": { "const": "vast" } },
+                      "required": ["asset_type"]
+                    },
+                    "then": { "required": ["vast_version"] }
+                  },
+                  {
+                    "if": { "type": "array" },
+                    "then": {
+                      "items": {
+                        "if": {
+                          "type": "object",
+                          "properties": { "asset_type": { "const": "vast" } },
+                          "required": ["asset_type"]
+                        },
+                        "then": { "required": ["vast_version"] }
+                      }
+                    }
+                  }
+                ]
+              }
+            }
+          }
+        }
+      }
+    }
+  ],
+  "type": "object",
+  "properties": {
+    "representation_id": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^[a-zA-Z0-9_-]+$",
+      "x-entity": "creative_representation",
+      "description": "Stable representation identifier, unique within the enclosing CreativeRepresentationSet revision."
+    },
+    "source": {
+      "type": "object",
+      "properties": {
+        "system": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Source system namespace."
+        },
+        "source_representation": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Source system's human-readable name for this representation."
+        },
+        "source_id": {
+          "type": "string",
+          "description": "Optional immutable source-system identifier for this representation."
+        }
+      },
+      "required": ["system", "source_representation"],
+      "additionalProperties": true
+    }
+  },
+  "required": ["representation_id", "source", "format_kind"],
+  "additionalProperties": true
+}
diff --git a/static/schemas/source/core/creative-revision-id.json b/static/schemas/source/core/creative-revision-id.json
new file mode 100644
index 0000000000..4c6e71827f
--- /dev/null
+++ b/static/schemas/source/core/creative-revision-id.json
@@ -0,0 +1,10 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/creative-revision-id.json",
+  "title": "Creative Revision ID",
+  "description": "Buyer-assigned identity for one immutable input-content state of a durable creative. Scoped to the parent creative_id. Seller transcoding, normalization, and delivery representations do not change this identity.",
+  "type": "string",
+  "minLength": 1,
+  "maxLength": 255,
+  "x-entity": "creative_revision"
+}
diff --git a/static/schemas/source/core/creative-variant.json b/static/schemas/source/core/creative-variant.json
index 083eef58d0..7012e00c26 100644
--- a/static/schemas/source/core/creative-variant.json
+++ b/static/schemas/source/core/creative-variant.json
@@ -2,12 +2,13 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "/schemas/core/creative-variant.json",
   "title": "Creative Variant",
-  "description": "A specific execution variant of a creative with delivery metrics. For catalog-driven packages, each catalog item rendered as a distinct ad execution is a variant — the variant's manifest includes the catalog reference with the specific item rendered. For asset group optimization, represents one combination of assets the platform selected. For generative creative, represents a platform-generated variant. For standard creatives, maps 1:1 with the creative itself.",
+  "description": "A revision- and locale-homogeneous execution-variant breakdown row with delivery metrics. For catalog-driven packages, each catalog item rendered as a distinct ad execution is a variant — the variant's manifest includes the catalog reference with the specific item rendered. For asset group optimization, represents one combination of assets the platform selected. For generative creative, represents a platform-generated variant. For standard creatives, maps 1:1 with the creative within one source revision and locale. Existing agents retain the published scope in which variant_id is unique within the agent and creative. An agent advertising creative.supports_revisions additionally mints a distinct agent-unique AdCP variant_id for every source revision, locale, or rendered execution so historical attribution and variant preview remain unambiguous.",
   "x-adcp-validation": {
     "verifier_constraints": {
       "localized_parent": {
         "required_field": "locale_variant_id",
-        "member_of": "list_creatives.localization.variants[].locale_variant_id",
+        "member_of": "accepted_source_revision.localization.variants[].locale_variant_id",
+        "current_list_localization_not_required": true,
         "applies_to_default_fallback": true
       }
     },
@@ -22,7 +23,29 @@
       "properties": {
         "variant_id": {
           "type": "string",
-          "description": "Platform-assigned identifier for this variant"
+          "description": "Agent-assigned served-execution identifier. The legacy contract scopes uniqueness to the agent and creative. When the agent advertises creative.supports_revisions, the identifier is agent-unique and MUST NOT be reused for another creative, source revision, locale, or rendered manifest. A revision-capable adapter whose native platform reuses an identifier maps each distinct execution to a distinct AdCP variant_id and may retain the native identifier in ext. When that agent supports variant preview, this ID is its unambiguous lookup key.",
+          "x-entity": "served_variant",
+          "x-adcp-validation": {
+            "verifier_constraints": {
+              "default_scope": "unique_within_agent_and_creative",
+              "when_creative_supports_revisions": "agent_unique_immutable_and_not_reused_across_creative_revision_locale_or_rendered_manifest"
+            },
+            "spec": "docs/creative/task-reference/get_creative_delivery.mdx#revision-attribution"
+          }
+        },
+        "revision_id": {
+          "$ref": "/schemas/core/creative-revision-id.json",
+          "description": "Buyer-authored input revision from which this served execution was derived. Required when that execution derives from a revision-aware creative. Historical reporting may legitimately return an older revision after list_creatives shows a newer current revision. Delivery optimization, generation, transcoding, or representation selection does not mint a revision.",
+          "x-adcp-validation": {
+            "verifier_constraints": {
+              "revision_attribution": {
+                "must_equal": "accepted_source_revision_for_this_execution",
+                "current_list_revision_not_required": true,
+                "row_metrics_revision_homogeneous": true
+              }
+            },
+            "spec": "docs/creative/task-reference/get_creative_delivery.mdx#revision-attribution"
+          }
         },
         "locale_variant_id": {
           "type": "string",
diff --git a/static/schemas/source/core/macro-bearing-url.json b/static/schemas/source/core/macro-bearing-url.json
new file mode 100644
index 0000000000..31c68f6d49
--- /dev/null
+++ b/static/schemas/source/core/macro-bearing-url.json
@@ -0,0 +1,25 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/macro-bearing-url.json",
+  "title": "Macro-bearing URL",
+  "description": "Backward-compatible URL value that preserves the existing `uri-template` branch (including deep links, protocol-relative references, and RFC 6570 host variables) while additionally accepting absolute HTTP(S) URLs with byte-preserved macro delimiters not legal in a strict URI, including `%%...%%`, `[...]`, and `${...}`. Macro-bearing HTTP(S) URLs require a valid lexical authority and valid percent triplets; an AdCP verifier replaces each recognized token with an unreserved sentinel and validates the resulting absolute URI. Token semantics are established only by `macro_declarations`.",
+  "x-adcp-validation": {
+    "verifier_constraints": {
+      "macro_aware_uri": "mask recognized token lexical forms with an RFC3986 unreserved sentinel, whether declared or on the undeclared 3.x compatibility path, then require a valid absolute HTTP or HTTPS URI; masking assigns no semantics"
+    },
+    "spec": "docs/creative/universal-macros.mdx#template-syntax"
+  },
+  "type": "string",
+  "anyOf": [
+    {
+      "format": "uri-template"
+    },
+    {
+      "format": "uri",
+      "pattern": "^https?://(?:[A-Za-z0-9._~!$&'()*+,;=:%-]+@)?(?:[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?|\\[[0-9A-Fa-f:.]+\\])(?::[0-9]{1,5})?(?:[/?#]|$)"
+    },
+    {
+      "pattern": "^https?://(?:[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?|\\[[0-9A-Fa-f:.]+\\])(?::[0-9]{1,5})?(?:[/?#](?:[^%\\s\\u0000-\\u001F\\u007F\"<>`\\\\]|%[0-9A-Fa-f]{2}|%%[A-Za-z0-9_.:-]+%%)*)?$"
+    }
+  ]
+}
diff --git a/static/schemas/source/core/macro-declaration.json b/static/schemas/source/core/macro-declaration.json
new file mode 100644
index 0000000000..94c225462e
--- /dev/null
+++ b/static/schemas/source/core/macro-declaration.json
@@ -0,0 +1,239 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/macro-declaration.json",
+  "title": "Macro Declaration",
+  "description": "The source-faithful contract for one occurrence of one macro token. It identifies the current dialect, verified mapping status, exact asset-field occurrence, next processing operation, actor, and encoding. Translation and concrete value resolution are separate operations: a translator emits the declared native token and replaces this declaration with the target declaration. Unknown tokens are always byte-preserved.",
+  "x-adcp-validation": {
+    "verifier_constraints": {
+      "adcp_semantic_identity": "when dialect is adcp, dialect_semantic must equal universal_semantic",
+      "declaration_id_uniqueness": "declaration_id must be unique within the containing asset",
+      "token_occurrence": "location must identify the declared zero-based occurrence of token in location.field",
+      "asset_field": "location.field must exist on and be permitted by the containing asset type",
+      "catalog_universal_profile": "catalog semantics require seller resolve_value in a URL context with exactly one rfc3986 pass",
+      "omit_parameter_scope": "omit_parameter requires the token to occupy the complete URL query-parameter value"
+    },
+    "spec": "docs/creative/universal-macros.mdx#declared-source-token-contracts"
+  },
+  "type": "object",
+  "properties": {
+    "declaration_id": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9_-]+$",
+      "minLength": 1,
+      "x-entity": "macro_declaration",
+      "description": "Identifier unique within the enclosing asset, used to correlate validation results."
+    },
+    "token": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Exact byte-preserved token expression at this occurrence, including delimiters."
+    },
+    "dialect": { "$ref": "/schemas/enums/macro-dialect.json" },
+    "dialect_namespace": {
+      "type": "string",
+      "format": "uri",
+      "description": "Authority-controlled registry or mapping URI. Required for IAB VAST, IAB DAAST, and vendor dialects."
+    },
+    "dialect_revision": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Immutable registry/mapping revision, release, commit, or digest. Required for IAB VAST, IAB DAAST, and vendor dialects."
+    },
+    "dialect_semantic": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Exact semantic identifier in the cited dialect, such as `CACHEBUSTING`, `PLAYERSTATE`, or a documented vendor name. This is not inferred from token spelling."
+    },
+    "mapping_status": { "$ref": "/schemas/enums/macro-mapping-status.json" },
+    "universal_semantic": {
+      "$ref": "/schemas/enums/universal-macro.json",
+      "description": "Verified AdCP universal meaning. Present only when mapping_status is `verified_universal`."
+    },
+    "operation": { "$ref": "/schemas/enums/macro-processing-operation.json" },
+    "performed_by": {
+      "$ref": "/schemas/enums/macro-resolver.json",
+      "description": "Actor authorized to perform the declared translation or value resolution. Omitted for preservation."
+    },
+    "translation_target": {
+      "$ref": "/schemas/core/macro-translation-target.json",
+      "description": "Required only for `translate_to_native`. The output token contract that replaces this declaration after translation."
+    },
+    "location": {
+      "type": "object",
+      "properties": {
+        "field": {
+          "type": "string",
+          "enum": ["url", "markup", "content", "ad_request_url", "clickthrough_url"],
+          "description": "Asset field containing this occurrence."
+        },
+        "occurrence": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Zero-based occurrence of this exact token within the named field."
+        },
+        "context": { "$ref": "/schemas/enums/macro-value-context.json" }
+      },
+      "required": ["field", "occurrence", "context"],
+      "additionalProperties": false
+    },
+    "encoding": {
+      "$ref": "/schemas/core/macro-encoding.json",
+      "description": "Encoding for the concrete value. Translation/preservation uses `none` at depth zero."
+    },
+    "required": {
+      "type": "boolean",
+      "description": "Whether terminal delivery must fail if the declared operation cannot complete."
+    },
+    "unavailable_behavior": {
+      "type": "string",
+      "enum": ["preserve", "omit_parameter", "dialect_sentinel", "reject"],
+      "description": "Action when the responsible actor has no value. Omission is legal only for a complete URL query-value occurrence; dialect sentinels require a cited dialect rule."
+    }
+  },
+  "required": [
+    "declaration_id",
+    "token",
+    "dialect",
+    "dialect_semantic",
+    "mapping_status",
+    "operation",
+    "location",
+    "encoding",
+    "required",
+    "unavailable_behavior"
+  ],
+  "additionalProperties": false,
+  "allOf": [
+    {
+      "if": { "properties": { "dialect": { "enum": ["iab_vast", "iab_daast", "vendor"] } }, "required": ["dialect"] },
+      "then": { "required": ["dialect_namespace", "dialect_revision"] }
+    },
+    {
+      "if": { "properties": { "dialect": { "enum": ["adcp", "unknown"] } }, "required": ["dialect"] },
+      "then": { "not": { "anyOf": [{ "required": ["dialect_namespace"] }, { "required": ["dialect_revision"] }] } }
+    },
+    {
+      "if": { "properties": { "mapping_status": { "const": "verified_universal" } }, "required": ["mapping_status"] },
+      "then": { "required": ["universal_semantic"] },
+      "else": { "not": { "required": ["universal_semantic"] } }
+    },
+    {
+      "if": { "properties": { "dialect": { "const": "adcp" } }, "required": ["dialect"] },
+      "then": {
+        "required": ["universal_semantic"],
+        "properties": {
+          "dialect_semantic": { "$ref": "/schemas/enums/universal-macro.json" },
+          "mapping_status": { "const": "verified_universal" }
+        }
+      }
+    },
+    {
+      "if": { "properties": { "dialect": { "const": "unknown" } }, "required": ["dialect"] },
+      "then": {
+        "properties": {
+          "mapping_status": { "const": "unresolved" },
+          "operation": { "const": "preserve" },
+          "encoding": { "properties": { "kind": { "const": "none" }, "depth": { "const": 0 } } },
+          "required": { "const": false },
+          "unavailable_behavior": { "const": "preserve" }
+        },
+        "not": { "anyOf": [{ "required": ["performed_by"] }, { "required": ["translation_target"] }, { "required": ["universal_semantic"] }] }
+      }
+    },
+    {
+      "if": { "properties": { "operation": { "const": "translate_to_native" } }, "required": ["operation"] },
+      "then": {
+        "required": ["performed_by", "translation_target"],
+        "properties": {
+          "mapping_status": { "enum": ["verified_universal", "dialect_defined"] },
+          "encoding": { "properties": { "kind": { "const": "none" }, "depth": { "const": 0 } } }
+        }
+      }
+    },
+    {
+      "if": { "properties": { "operation": { "const": "resolve_value" } }, "required": ["operation"] },
+      "then": {
+        "required": ["performed_by"],
+        "properties": { "mapping_status": { "enum": ["verified_universal", "dialect_defined"] } },
+        "not": { "required": ["translation_target"] }
+      }
+    },
+    {
+      "if": {
+        "properties": { "dialect": { "enum": ["iab_vast", "iab_daast"] }, "operation": { "const": "resolve_value" } },
+        "required": ["dialect", "operation"]
+      },
+      "then": { "properties": { "performed_by": { "const": "request_executor" } } }
+    },
+    {
+      "if": { "properties": { "operation": { "const": "preserve" } }, "required": ["operation"] },
+      "then": {
+        "properties": {
+          "encoding": { "properties": { "kind": { "const": "none" }, "depth": { "const": 0 } } },
+          "required": { "const": false },
+          "unavailable_behavior": { "const": "preserve" }
+        },
+        "not": { "anyOf": [{ "required": ["performed_by"] }, { "required": ["translation_target"] }] }
+      }
+    },
+    {
+      "if": {
+        "properties": { "location": { "properties": { "context": { "const": "opaque" } }, "required": ["context"] } },
+        "required": ["location"]
+      },
+      "then": {
+        "properties": {
+          "operation": { "const": "preserve" },
+          "encoding": { "properties": { "kind": { "const": "none" }, "depth": { "const": 0 } } },
+          "required": { "const": false },
+          "unavailable_behavior": { "const": "preserve" }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "universal_semantic": {
+            "enum": ["CATALOG_ID", "SKU", "GTIN", "OFFERING_ID", "JOB_ID", "HOTEL_ID", "FLIGHT_ID", "VEHICLE_ID", "LISTING_ID", "STORE_ID", "PROGRAM_ID", "DESTINATION_ID", "ITEM_NAME", "ITEM_DESCRIPTION", "ITEM_TAGLINE", "ITEM_PRICE", "ITEM_PRICE_CURRENCY"]
+          }
+        },
+        "required": ["universal_semantic"]
+      },
+      "then": {
+        "properties": {
+          "operation": { "const": "resolve_value" },
+          "performed_by": { "const": "seller" },
+          "location": { "properties": { "context": { "enum": ["url_query_value", "url_path_segment"] } } },
+          "encoding": { "properties": { "kind": { "const": "rfc3986" }, "depth": { "const": 1 } } }
+        }
+      }
+    },
+    {
+      "if": { "properties": { "required": { "const": true } }, "required": ["required"] },
+      "then": { "properties": { "unavailable_behavior": { "const": "reject" } } }
+    },
+    {
+      "if": { "properties": { "unavailable_behavior": { "const": "omit_parameter" } }, "required": ["unavailable_behavior"] },
+      "then": {
+        "properties": {
+          "operation": { "const": "resolve_value" },
+          "location": { "properties": { "context": { "const": "url_query_value" } } }
+        }
+      }
+    },
+    {
+      "if": { "properties": { "unavailable_behavior": { "const": "preserve" } }, "required": ["unavailable_behavior"] },
+      "then": { "properties": { "operation": { "const": "preserve" } } }
+    },
+    {
+      "if": { "properties": { "unavailable_behavior": { "const": "dialect_sentinel" } }, "required": ["unavailable_behavior"] },
+      "then": {
+        "properties": {
+          "dialect": { "const": "iab_vast" },
+          "operation": { "const": "resolve_value" },
+          "required": { "const": false }
+        }
+      }
+    }
+  ]
+}
diff --git a/static/schemas/source/core/macro-encoding.json b/static/schemas/source/core/macro-encoding.json
new file mode 100644
index 0000000000..8b4ca0717d
--- /dev/null
+++ b/static/schemas/source/core/macro-encoding.json
@@ -0,0 +1,33 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/macro-encoding.json",
+  "title": "Macro Encoding",
+  "description": "Exact encoding profile applied to a concrete substitution value. `rfc3986` encodes UTF-8 bytes outside the RFC 3986 unreserved set once per depth. `iab_vast_uri` follows the cited IAB VAST macro registry, including its array serialization rules, and is exactly one pass.",
+  "type": "object",
+  "properties": {
+    "kind": {
+      "type": "string",
+      "enum": ["none", "rfc3986", "iab_vast_uri"]
+    },
+    "depth": {
+      "type": "integer",
+      "minimum": 0
+    }
+  },
+  "required": ["kind", "depth"],
+  "additionalProperties": false,
+  "allOf": [
+    {
+      "if": { "properties": { "kind": { "const": "none" } }, "required": ["kind"] },
+      "then": { "properties": { "depth": { "const": 0 } } }
+    },
+    {
+      "if": { "properties": { "kind": { "const": "rfc3986" } }, "required": ["kind"] },
+      "then": { "properties": { "depth": { "minimum": 1 } } }
+    },
+    {
+      "if": { "properties": { "kind": { "const": "iab_vast_uri" } }, "required": ["kind"] },
+      "then": { "properties": { "depth": { "const": 1 } } }
+    }
+  ]
+}
diff --git a/static/schemas/source/core/macro-resolution-capability.json b/static/schemas/source/core/macro-resolution-capability.json
new file mode 100644
index 0000000000..894e5cff73
--- /dev/null
+++ b/static/schemas/source/core/macro-resolution-capability.json
@@ -0,0 +1,131 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/macro-resolution-capability.json",
+  "title": "Macro Processing Capability",
+  "description": "One exact processing capability for one governed dialect semantic, operation, actor, occurrence context, and encoding set. Entries are intentionally semantic-specific; they do not create a semantics × maximum-depth cross-product. Seller-wide capabilities are only a ceiling and the selected product format option is binding.",
+  "x-adcp-validation": {
+    "verifier_constraints": {
+      "adcp_semantic_identity": "when dialect is adcp, dialect_semantic must equal universal_semantic",
+      "translation_chain": "a translate_to_native entry is usable only when the same capability set contains an exact resolve_value entry for translation_target"
+    },
+    "spec": "docs/creative/universal-macros.mdx#capability-matching-and-validation"
+  },
+  "type": "object",
+  "properties": {
+    "dialect": { "$ref": "/schemas/enums/macro-dialect.json" },
+    "dialect_namespace": { "type": "string", "format": "uri" },
+    "dialect_revision": { "type": "string", "minLength": 1 },
+    "dialect_semantic": { "type": "string", "minLength": 1 },
+    "mapping_status": {
+      "type": "string",
+      "enum": ["verified_universal", "dialect_defined"]
+    },
+    "universal_semantic": { "$ref": "/schemas/enums/universal-macro.json" },
+    "operation": {
+      "type": "string",
+      "enum": ["translate_to_native", "resolve_value"]
+    },
+    "performed_by": { "$ref": "/schemas/enums/macro-resolver.json" },
+    "supported_contexts": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "allOf": [
+          { "$ref": "/schemas/enums/macro-value-context.json" },
+          { "not": { "const": "opaque" } }
+        ]
+      }
+    },
+    "supported_encodings": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": { "$ref": "/schemas/core/macro-encoding.json" },
+      "description": "Exact supported encoding profiles, not a maximum depth. Required for value resolution."
+    },
+    "translation_target": { "$ref": "/schemas/core/macro-translation-target.json" }
+  },
+  "required": [
+    "dialect",
+    "dialect_semantic",
+    "mapping_status",
+    "operation",
+    "performed_by",
+    "supported_contexts"
+  ],
+  "additionalProperties": false,
+  "allOf": [
+    {
+      "if": { "properties": { "dialect": { "enum": ["iab_vast", "iab_daast", "vendor"] } }, "required": ["dialect"] },
+      "then": { "required": ["dialect_namespace", "dialect_revision"] }
+    },
+    {
+      "if": { "properties": { "dialect": { "enum": ["adcp", "unknown"] } }, "required": ["dialect"] },
+      "then": { "not": { "anyOf": [{ "required": ["dialect_namespace"] }, { "required": ["dialect_revision"] }] } }
+    },
+    {
+      "if": { "properties": { "dialect": { "const": "unknown" } }, "required": ["dialect"] },
+      "then": false
+    },
+    {
+      "if": { "properties": { "mapping_status": { "const": "verified_universal" } }, "required": ["mapping_status"] },
+      "then": { "required": ["universal_semantic"] },
+      "else": { "not": { "required": ["universal_semantic"] } }
+    },
+    {
+      "if": { "properties": { "dialect": { "const": "adcp" } }, "required": ["dialect"] },
+      "then": {
+        "required": ["universal_semantic"],
+        "properties": {
+          "dialect_semantic": { "$ref": "/schemas/enums/universal-macro.json" },
+          "mapping_status": { "const": "verified_universal" }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "universal_semantic": {
+            "enum": ["CATALOG_ID", "SKU", "GTIN", "OFFERING_ID", "JOB_ID", "HOTEL_ID", "FLIGHT_ID", "VEHICLE_ID", "LISTING_ID", "STORE_ID", "PROGRAM_ID", "DESTINATION_ID", "ITEM_NAME", "ITEM_DESCRIPTION", "ITEM_TAGLINE", "ITEM_PRICE", "ITEM_PRICE_CURRENCY"]
+          }
+        },
+        "required": ["universal_semantic"]
+      },
+      "then": {
+        "properties": {
+          "operation": { "const": "resolve_value" },
+          "performed_by": { "const": "seller" },
+          "supported_contexts": { "items": { "enum": ["url_query_value", "url_path_segment"] } },
+          "supported_encodings": {
+            "items": {
+              "properties": { "kind": { "const": "rfc3986" }, "depth": { "const": 1 } },
+              "required": ["kind", "depth"]
+            }
+          }
+        }
+      }
+    },
+    {
+      "if": { "properties": { "operation": { "const": "resolve_value" } }, "required": ["operation"] },
+      "then": {
+        "required": ["supported_encodings"],
+        "not": { "required": ["translation_target"] }
+      }
+    },
+    {
+      "if": {
+        "properties": { "dialect": { "enum": ["iab_vast", "iab_daast"] }, "operation": { "const": "resolve_value" } },
+        "required": ["dialect", "operation"]
+      },
+      "then": { "properties": { "performed_by": { "const": "request_executor" } } }
+    },
+    {
+      "if": { "properties": { "operation": { "const": "translate_to_native" } }, "required": ["operation"] },
+      "then": {
+        "required": ["translation_target"],
+        "not": { "required": ["supported_encodings"] }
+      }
+    }
+  ]
+}
diff --git a/static/schemas/source/core/macro-resolution-result.json b/static/schemas/source/core/macro-resolution-result.json
new file mode 100644
index 0000000000..194b91275f
--- /dev/null
+++ b/static/schemas/source/core/macro-resolution-result.json
@@ -0,0 +1,157 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/macro-resolution-result.json",
+  "title": "Macro Resolution Result",
+  "description": "Path-addressable preflight result for one declaration. `resolvable` means the selected execution path advertises the exact operation; it does not claim that serve-time substitution has already occurred.",
+  "x-adcp-validation": {
+    "verifier_constraints": {
+      "adcp_semantic_identity": "when dialect is adcp, dialect_semantic must equal universal_semantic"
+    },
+    "spec": "docs/creative/universal-macros.mdx#capability-matching-and-validation"
+  },
+  "type": "object",
+  "properties": {
+    "declaration_id": { "type": "string", "minLength": 1, "x-entity": "macro_declaration" },
+    "asset_path": {
+      "type": "string",
+      "pattern": "^/",
+      "description": "JSON Pointer to the asset carrying the declaration."
+    },
+    "token": { "type": "string", "minLength": 1 },
+    "dialect": { "$ref": "/schemas/enums/macro-dialect.json" },
+    "dialect_namespace": { "type": "string", "format": "uri" },
+    "dialect_revision": { "type": "string", "minLength": 1 },
+    "dialect_semantic": { "type": "string", "minLength": 1 },
+    "mapping_status": { "$ref": "/schemas/enums/macro-mapping-status.json" },
+    "universal_semantic": { "$ref": "/schemas/enums/universal-macro.json" },
+    "operation": { "$ref": "/schemas/enums/macro-processing-operation.json" },
+    "performed_by": { "$ref": "/schemas/enums/macro-resolver.json" },
+    "requested_encoding": { "$ref": "/schemas/core/macro-encoding.json" },
+    "required": { "type": "boolean" },
+    "unavailable_behavior": {
+      "type": "string",
+      "enum": ["preserve", "omit_parameter", "dialect_sentinel", "reject"]
+    },
+    "status": {
+      "type": "string",
+      "enum": ["resolvable", "preserved_for_downstream", "unsupported", "ambiguous"]
+    },
+    "reason": { "$ref": "/schemas/enums/macro-resolution-reason.json" },
+    "matched_encodings": {
+      "type": "array",
+      "items": { "$ref": "/schemas/core/macro-encoding.json" },
+      "description": "Exact advertised profiles considered for this match, when relevant."
+    },
+    "message": { "type": "string", "minLength": 1 }
+  },
+  "required": [
+    "declaration_id",
+    "asset_path",
+    "token",
+    "dialect",
+    "dialect_semantic",
+    "mapping_status",
+    "operation",
+    "requested_encoding",
+    "required",
+    "unavailable_behavior",
+    "status",
+    "reason"
+  ],
+  "additionalProperties": false,
+  "allOf": [
+    {
+      "if": { "properties": { "dialect": { "enum": ["iab_vast", "iab_daast", "vendor"] } }, "required": ["dialect"] },
+      "then": { "required": ["dialect_namespace", "dialect_revision"] }
+    },
+    {
+      "if": { "properties": { "dialect": { "enum": ["adcp", "unknown"] } }, "required": ["dialect"] },
+      "then": { "not": { "anyOf": [{ "required": ["dialect_namespace"] }, { "required": ["dialect_revision"] }] } }
+    },
+    {
+      "if": { "properties": { "mapping_status": { "const": "verified_universal" } }, "required": ["mapping_status"] },
+      "then": { "required": ["universal_semantic"] },
+      "else": { "not": { "required": ["universal_semantic"] } }
+    },
+    {
+      "if": { "properties": { "operation": { "enum": ["translate_to_native", "resolve_value"] } }, "required": ["operation"] },
+      "then": { "required": ["performed_by"] }
+    },
+    {
+      "if": {
+        "properties": { "dialect": { "enum": ["iab_vast", "iab_daast"] }, "operation": { "const": "resolve_value" } },
+        "required": ["dialect", "operation"]
+      },
+      "then": { "properties": { "performed_by": { "const": "request_executor" } } }
+    },
+    {
+      "if": { "properties": { "dialect": { "const": "adcp" } }, "required": ["dialect"] },
+      "then": {
+        "required": ["universal_semantic"],
+        "properties": {
+          "dialect_semantic": { "$ref": "/schemas/enums/universal-macro.json" },
+          "mapping_status": { "const": "verified_universal" }
+        }
+      }
+    },
+    {
+      "if": { "properties": { "dialect": { "const": "unknown" } }, "required": ["dialect"] },
+      "then": {
+        "properties": {
+          "mapping_status": { "const": "unresolved" },
+          "operation": { "const": "preserve" },
+          "requested_encoding": { "properties": { "kind": { "const": "none" }, "depth": { "const": 0 } } },
+          "required": { "const": false },
+          "unavailable_behavior": { "const": "preserve" },
+          "status": { "const": "preserved_for_downstream" },
+          "reason": { "const": "preserved_unknown" }
+        },
+        "not": { "anyOf": [{ "required": ["performed_by"] }, { "required": ["universal_semantic"] }] }
+      }
+    },
+    {
+      "if": { "properties": { "operation": { "const": "preserve" } }, "required": ["operation"] },
+      "then": {
+        "properties": {
+          "requested_encoding": { "properties": { "kind": { "const": "none" }, "depth": { "const": 0 } } },
+          "required": { "const": false },
+          "unavailable_behavior": { "const": "preserve" },
+          "status": { "const": "preserved_for_downstream" }
+        },
+        "not": { "required": ["performed_by"] }
+      }
+    },
+    {
+      "if": { "properties": { "required": { "const": true } }, "required": ["required"] },
+      "then": { "properties": { "unavailable_behavior": { "const": "reject" } } }
+    },
+    {
+      "if": { "properties": { "status": { "const": "resolvable" } }, "required": ["status"] },
+      "then": { "properties": { "reason": { "const": "capability_match" } } }
+    },
+    {
+      "if": { "properties": { "status": { "const": "preserved_for_downstream" } }, "required": ["status"] },
+      "then": {
+        "properties": {
+          "operation": { "const": "preserve" },
+          "reason": { "enum": ["preserved_unknown", "preserved_for_downstream"] }
+        },
+        "not": { "required": ["performed_by"] }
+      }
+    },
+    {
+      "if": { "properties": { "status": { "const": "unsupported" } }, "required": ["status"] },
+      "then": {
+        "properties": {
+          "reason": {
+            "enum": ["dialect_unsupported", "namespace_mismatch", "revision_mismatch", "semantic_unsupported", "operation_unsupported", "resolver_mismatch", "context_unsupported", "encoding_unsupported"]
+          }
+        }
+      }
+    },
+    {
+      "if": { "properties": { "status": { "const": "ambiguous" } }, "required": ["status"] },
+      "then": { "properties": { "reason": { "const": "ambiguous_mapping" } } }
+    }
+  ]
+}
diff --git a/static/schemas/source/core/macro-translation-target.json b/static/schemas/source/core/macro-translation-target.json
new file mode 100644
index 0000000000..2bc3e770d4
--- /dev/null
+++ b/static/schemas/source/core/macro-translation-target.json
@@ -0,0 +1,73 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/macro-translation-target.json",
+  "title": "Macro Translation Target",
+  "description": "The exact downstream-native token produced by a `translate_to_native` operation. The output asset replaces the source declaration with a declaration for this token and its next operation.",
+  "type": "object",
+  "properties": {
+    "token": { "type": "string", "minLength": 1 },
+    "dialect": { "$ref": "/schemas/enums/macro-dialect.json" },
+    "dialect_namespace": { "type": "string", "format": "uri" },
+    "dialect_revision": { "type": "string", "minLength": 1 },
+    "dialect_semantic": { "type": "string", "minLength": 1 },
+    "mapping_status": { "$ref": "/schemas/enums/macro-mapping-status.json" },
+    "universal_semantic": { "$ref": "/schemas/enums/universal-macro.json" },
+    "next_operation": {
+      "type": "string",
+      "const": "resolve_value"
+    },
+    "performed_by": { "$ref": "/schemas/enums/macro-resolver.json" },
+    "encoding": { "$ref": "/schemas/core/macro-encoding.json" }
+  },
+  "required": ["token", "dialect", "dialect_semantic", "mapping_status", "next_operation", "performed_by", "encoding"],
+  "additionalProperties": false,
+  "allOf": [
+    {
+      "if": { "properties": { "dialect": { "enum": ["iab_vast", "iab_daast", "vendor"] } }, "required": ["dialect"] },
+      "then": { "required": ["dialect_namespace", "dialect_revision"] }
+    },
+    {
+      "if": { "properties": { "dialect": { "enum": ["adcp", "unknown"] } }, "required": ["dialect"] },
+      "then": { "not": { "anyOf": [{ "required": ["dialect_namespace"] }, { "required": ["dialect_revision"] }] } }
+    },
+    {
+      "if": { "properties": { "dialect": { "const": "unknown" } }, "required": ["dialect"] },
+      "then": false
+    },
+    {
+      "if": { "properties": { "mapping_status": { "const": "verified_universal" } }, "required": ["mapping_status"] },
+      "then": { "required": ["universal_semantic"] },
+      "else": { "not": { "required": ["universal_semantic"] } }
+    },
+    {
+      "if": { "properties": { "dialect": { "enum": ["iab_vast", "iab_daast"] } }, "required": ["dialect"] },
+      "then": { "properties": { "performed_by": { "const": "request_executor" } } }
+    },
+    {
+      "if": { "properties": { "dialect": { "const": "adcp" } }, "required": ["dialect"] },
+      "then": {
+        "required": ["universal_semantic"],
+        "properties": {
+          "dialect_semantic": { "$ref": "/schemas/enums/universal-macro.json" },
+          "mapping_status": { "const": "verified_universal" }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "universal_semantic": {
+            "enum": ["CATALOG_ID", "SKU", "GTIN", "OFFERING_ID", "JOB_ID", "HOTEL_ID", "FLIGHT_ID", "VEHICLE_ID", "LISTING_ID", "STORE_ID", "PROGRAM_ID", "DESTINATION_ID", "ITEM_NAME", "ITEM_DESCRIPTION", "ITEM_TAGLINE", "ITEM_PRICE", "ITEM_PRICE_CURRENCY"]
+          }
+        },
+        "required": ["universal_semantic"]
+      },
+      "then": {
+        "properties": {
+          "performed_by": { "const": "seller" },
+          "encoding": { "properties": { "kind": { "const": "rfc3986" }, "depth": { "const": 1 } } }
+        }
+      }
+    }
+  ]
+}
diff --git a/static/schemas/source/core/product-format-declaration.json b/static/schemas/source/core/product-format-declaration.json
index 86da5267ec..9504317349 100644
--- a/static/schemas/source/core/product-format-declaration.json
+++ b/static/schemas/source/core/product-format-declaration.json
@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "/schemas/core/product-format-declaration.json",
   "title": "Product Format Declaration",
-  "description": "Inline format declaration on a product. The `format_kind` discriminator names which canonical format the product narrows; `params` carries the canonical's parameter schema (slots, dimensions, durations, codecs, character limits, platform_extensions, etc.). Optional `format_option_id` (stable identifier for routing when a product's `format_options` contains multiple declarations sharing the same `format_kind`), optional `publisher_domain` (namespace for the format option when it comes from a publisher adagents.json catalog), `display_name` (seller-controlled human-readable label for dashboard and catalog UIs), and `applies_to_channels` (subset of the product's declared channels this declaration applies to — lets a multi-channel product carry distinct format_options per channel). Discriminated-union shape generates clean tagged unions in TypeScript and Pydantic codegen. Replaces v1's named-format pattern (where products referenced a separately-defined format file via compound `format_id`). Canonical product-bound declarations are the AdCP 3.2 authoring path; v1 named formats remain only as deprecated 3.x compatibility projections.\n\n**Closed-set semantics (normative).** `format_options[]` is the closed set of accepted formats for this product. Sellers MUST reject `create_media_buy` requests targeting any `format_kind` (or format option reference) not present in this list — typically with `UNSUPPORTED_FEATURE` or a seller-specific code; the rejection is structural, not negotiable. `seller_preference` modulates *within* the accepted set (a soft ranking hint between equally-acceptable options), it is NOT an enforcement axis. A product wanting to say 'this format is the only one that works' lists exactly that one entry in `format_options[]`; everything else falls outside the set and is rejected by the closed-set rule.\n\n**Format matching vs satisfaction (normative).** Legacy named formats MUST be normalized to canonical declarations before comparison; do not exact-match raw `(agent_url, id)` pairs once a `format_id` has been projected through `canonical`, `v1_format_ref`, or the canonical mapping registry. Equivalence matching can treat a legacy fixed-size display ID and `format_kind: \"image\"` with matching `width`/`height` as the same underlying shape. Product satisfaction is stricter and directional: when this declaration specifies fixed constraints such as `width`, `height`, `duration_ms_exact`, or `duration_ms_range`, a buyer request or creative manifest MUST declare and satisfy those constraints. A broad request with no dimensions or duration does not satisfy a fixed-size or fixed-duration product; a broad product MAY accept a more specific creative unless another product constraint excludes it. Duration precedence is `duration_ms_exact` > `duration_ms_range`. Range constraints use containment: a range-based request satisfies this declaration only when every value it permits falls within this declaration's accepted range; overlap alone is insufficient. An exact value satisfies a range when the exact value falls inside the accepted interval. For hosted audio/video, a null range endpoint is unbounded: [null, 60000] means up to 60s, and [15000, null] means at least 15s; [null, null] is invalid because at least one endpoint must be bounded.\n\n**Custom format_kind** (`format_kind: \"custom\"`): for adopter-defined shapes that don't fit the 14 canonicals (branded content, cross-screen sponsorship, sponsorship lockup, newsletter sponsorship, AR lens, playable, live event sponsorship). When `format_kind` is `custom`, the declaration MUST carry `format_shape` (recognized global pattern from the [format-shape vocabulary registry](/schemas/core/format-shape-vocabulary.json)) AND `format_schema` (URI+digest reference to a fetchable schema describing the actual `params` and `slots`). Buyer agents fetch the schema, validate manifests structurally, and reason about manifests without per-seller integration code. See [adcp#3666](https://github.com/adcontextprotocol/adcp/issues/3666) for the canonical promotion queue.",
+  "description": "Inline format declaration on a product. The `format_kind` discriminator names which canonical format the product narrows; `params` carries only the canonical creative-shape parameters (slots, dimensions, durations, codecs, character limits, platform_extensions, etc.). Processing metadata such as `macro_resolution_capabilities` belongs at this declaration's top level rather than inside `params`. Optional `format_option_id` (stable identifier for routing when a product's `format_options` contains multiple declarations sharing the same `format_kind`), optional `publisher_domain` (namespace for the format option when it comes from a publisher adagents.json catalog), `display_name` (seller-controlled human-readable label for dashboard and catalog UIs), and `applies_to_channels` (subset of the product's declared channels this declaration applies to — lets a multi-channel product carry distinct format_options per channel). Discriminated-union shape generates clean tagged unions in TypeScript and Pydantic codegen. Replaces v1's named-format pattern (where products referenced a separately-defined format file via compound `format_id`). Canonical product-bound declarations are the AdCP 3.2 authoring path; v1 named formats remain only as deprecated 3.x compatibility projections.\n\n**Closed-set semantics (normative).** `format_options[]` is the closed set of accepted formats for this product. Sellers MUST reject `create_media_buy` requests targeting any `format_kind` (or format option reference) not present in this list — typically with `UNSUPPORTED_FEATURE` or a seller-specific code; the rejection is structural, not negotiable. `seller_preference` modulates *within* the accepted set (a soft ranking hint between equally-acceptable options), it is NOT an enforcement axis. A product wanting to say 'this format is the only one that works' lists exactly that one entry in `format_options[]`; everything else falls outside the set and is rejected by the closed-set rule.\n\n**Format matching vs satisfaction (normative).** Legacy named formats MUST be normalized to canonical declarations before comparison; do not exact-match raw `(agent_url, id)` pairs once a `format_id` has been projected through `canonical`, `v1_format_ref`, or the canonical mapping registry. Equivalence matching can treat a legacy fixed-size display ID and `format_kind: \"image\"` with matching `width`/`height` as the same underlying shape. Product satisfaction is stricter and directional: when this declaration specifies fixed constraints such as `width`, `height`, `duration_ms_exact`, or `duration_ms_range`, a buyer request or creative manifest MUST declare and satisfy those constraints. A broad request with no dimensions or duration does not satisfy a fixed-size or fixed-duration product; a broad product MAY accept a more specific creative unless another product constraint excludes it. Duration precedence is `duration_ms_exact` > `duration_ms_range`. Range constraints use containment: a range-based request satisfies this declaration only when every value it permits falls within this declaration's accepted range; overlap alone is insufficient. An exact value satisfies a range when the exact value falls inside the accepted interval. For hosted audio/video, a null range endpoint is unbounded: [null, 60000] means up to 60s, and [15000, null] means at least 15s; [null, null] is invalid because at least one endpoint must be bounded.\n\n**Custom format_kind** (`format_kind: \"custom\"`): for adopter-defined shapes that don't fit the 14 canonicals (branded content, cross-screen sponsorship, sponsorship lockup, newsletter sponsorship, AR lens, playable, live event sponsorship). When `format_kind` is `custom`, the declaration MUST carry `format_shape` (recognized global pattern from the [format-shape vocabulary registry](/schemas/core/format-shape-vocabulary.json)) AND `format_schema` (URI+digest reference to a fetchable schema describing the actual `params` and `slots`). Buyer agents fetch the schema, validate manifests structurally, and reason about manifests without per-seller integration code. See [adcp#3666](https://github.com/adcontextprotocol/adcp/issues/3666) for the canonical promotion queue.",
   "type": "object",
   "required": ["format_kind", "params"],
   "discriminator": { "propertyName": "format_kind" },
@@ -16,6 +16,21 @@
       "pattern": "^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$",
       "description": "Namespace for `format_option_id` when this declaration references or narrows a publisher-declared format option from that publisher's adagents.json top-level `formats[]`. Product-local options omit this field and are selected by `format_option_id` within the target product."
     },
+    "macro_resolution_capabilities": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "/schemas/core/macro-resolution-capability.json" },
+      "description": "Binding format-option processing capabilities for exact macro dialect identities, semantics, operations, actors, contexts, and encodings. Absence means undeclared, not supported on the opt-in declared-token path. Seller-wide capabilities are only a ceiling. This field does not claim that a buyer tracker asset is honored or fired.",
+      "x-adcp-validation": {
+        "verifier_constraints": {
+          "translation_chain_closure": "every translate_to_native entry must have an exact matching resolve_value entry for its translation_target in this same array"
+        }
+      }
+    },
+    "technical_requirements_complete": {
+      "type": "boolean",
+      "description": "Completeness assertion for technical creative acceptance constraints in this declaration. When true, the declaring party asserts that every technical constraint within its authority is expressed by this declaration (including fetched custom-format and platform-extension schemas), and every omitted technical field means no constraint at that layer. A creative that satisfies the complete effective technical contract MUST NOT later be rejected for an undisclosed technical constraint. When false or absent, omitted technical constraints are undeclared: consumers MUST NOT interpret omission as support, no constraint, or a prose/default value. The effective product/placement contract is complete only when every applicable product, publisher, and placement declaration asserts true. This assertion is limited to technical acceptance; it does not waive policy, legal, security, malware, transport/fetch, corrupted-content, or materially misdeclared-asset checks. Creative size fields ending in `_kb` use exactly 1,000 bytes per KB and fields ending in `_mb` use exactly 1,000,000 bytes per MB."
+    },
     "display_name": {
       "type": "string",
       "description": "Optional seller-controlled human-readable label for this format declaration. Used by buyer dashboards, catalog UIs, and reporting surfaces to show a seller's own naming ('Homepage Takeover', 'Branded Canvas', 'Reels Premium Video') rather than the raw `format_kind` or `format_option_id`. Has no machine semantics — buyer agents route on `format_kind` and `format_option_id`; `display_name` is purely for human presentation. Freeform; no enumeration. Sellers SHOULD keep it stable once published to avoid dashboard churn."
diff --git a/static/schemas/source/core/representation-destination.json b/static/schemas/source/core/representation-destination.json
new file mode 100644
index 0000000000..13aa7a1320
--- /dev/null
+++ b/static/schemas/source/core/representation-destination.json
@@ -0,0 +1,37 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/representation-destination.json",
+  "title": "Representation Destination",
+  "description": "Seller-owned inventory context against which a CreativeRepresentationSet is resolved. This object is valid only when build_creative is invoked on the destination sales agent. The seller resolves product_id to its current product, verifies that format_option is an exact current effective declaration for the requested placements, and intersects it with its own current seller-wide execution capabilities. A standalone creative agent cannot use this object to claim seller deliverability.",
+  "x-adcp-validation": {
+    "verifier_constraints": {
+      "seller_authority": "the build_creative endpoint MUST be the sales agent that owns product_id",
+      "current_product_match": "format_option MUST exactly match one effective current format option for product_id after every applicable placement and publisher narrowing",
+      "placement_scope": "when placement_refs is omitted, the representation must satisfy the common effective contract for every placement where the product may deliver",
+      "execution_intersection": "resolution additionally intersects the seller's current media_buy.execution.creative_specs VAST and macro ceilings; the request does not override those capabilities"
+    },
+    "spec": "docs/creative/representation-sets.mdx#seller-bound-resolution"
+  },
+  "type": "object",
+  "properties": {
+    "product_id": {
+      "type": "string",
+      "minLength": 1,
+      "x-entity": "product",
+      "description": "Product owned by the destination seller."
+    },
+    "format_option": {
+      "$ref": "/schemas/core/product-format-declaration.json",
+      "description": "Exact effective destination declaration. The full declaration is carried so an option without format_option_id remains addressable. The destination seller verifies it against the current product and applicable placement/publisher narrowings."
+    },
+    "placement_refs": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": { "$ref": "/schemas/core/placement-ref.json" },
+      "description": "Optional placements the derived manifest must satisfy. Omission means every placement in the intended product route, not an unconstrained destination."
+    }
+  },
+  "required": ["product_id", "format_option"],
+  "additionalProperties": false
+}
diff --git a/static/schemas/source/core/representation-rejection.json b/static/schemas/source/core/representation-rejection.json
new file mode 100644
index 0000000000..b369408428
--- /dev/null
+++ b/static/schemas/source/core/representation-rejection.json
@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/representation-rejection.json",
+  "title": "Representation Rejection",
+  "description": "Structured incompatibility reason for one candidate in a failed CreativeRepresentationSet resolution.",
+  "type": "object",
+  "properties": {
+    "representation_id": { "type": "string", "minLength": 1, "x-entity": "creative_representation" },
+    "code": {
+      "type": "string",
+      "enum": [
+        "incompatible_format_kind",
+        "format_option_mismatch",
+        "unsupported_delivery_type",
+        "vast_version_mismatch",
+        "macro_unsupported",
+        "asset_requirement_failed",
+        "other"
+      ]
+    },
+    "message": { "type": "string", "minLength": 1 },
+    "details": { "type": "object", "additionalProperties": true }
+  },
+  "required": ["representation_id", "code", "message"],
+  "additionalProperties": true
+}
diff --git a/static/schemas/source/core/representation-selection.json b/static/schemas/source/core/representation-selection.json
new file mode 100644
index 0000000000..9e26f37c41
--- /dev/null
+++ b/static/schemas/source/core/representation-selection.json
@@ -0,0 +1,60 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/representation-selection.json",
+  "title": "Representation Selection",
+  "description": "Readback lineage from a seller-bound manifest or CreativeAsset to the exact CreativeRepresentationSet revision and representation selected for it. This is selection lineage, not served-variant identity.",
+  "x-adcp-validation": {
+    "verifier_constraints": {
+      "source_set": {
+        "creative_id": "must equal the source CreativeRepresentationSet creative_id",
+        "revision_id": "must equal the source CreativeRepresentationSet revision_id",
+        "revision_content_digest": "must equal the verified digest of the complete source CreativeRepresentationSet",
+        "selected_representation_id": "must identify exactly one member of the complete source representations array",
+        "strategy": "must equal the capability-advertised strategy requested for this resolution"
+      },
+      "derived_output": {
+        "source_revision_unchanged": "selection, macro binding, translation, and transcoding MUST NOT change the source revision binding",
+        "canonical_content": "RFC 8785 JCS of the manifest projection after removing exactly top-level $schema, representation_selection, creative_id, revision_id, name, tags, status, weight, placement_refs, placement_ids, and inputs properties; every other field, including unknown delivery fields, is included",
+        "shared_projection": "apply the same exclusion list to the returned CreativeManifest and to its later CreativeAsset sync wrapper so library metadata never changes the digest",
+        "selected_output_digest": "must equal lowercase-hex SHA-256 of derived-output canonical content before receiving-seller normalization",
+        "review_identity": "the receiving seller tracks selected_representation_id plus selected_output_digest separately from the source revision; changing either is an updated execution that follows ordinary re-review without minting a buyer revision",
+        "approval_boundary": "the exact selected output MUST complete the receiving seller's ordinary validation and review before serving; approval of one candidate never approves another",
+        "runtime_selection": "selection is pinned at trafficking time and MUST NOT be changed per viewer or device; device and player fallback stays within the selected manifest or VAST document",
+        "selection_stability": "after sync_creatives accepts this lineage, later product, placement, VAST, macro, or seller-capability changes MUST NOT cause implicit re-resolution, lineage replacement, or buyer re-review; only an explicit buyer-submitted selected output may replace it",
+        "seller_inability": "if the seller can no longer serve the pinned execution, it MUST preserve this lineage and use ordinary seller/system creative-status and media-buy impairment surfaces rather than silently substituting another representation"
+      }
+    },
+    "spec": "docs/creative/representation-sets.mdx#seller-bound-resolution"
+  },
+  "type": "object",
+  "properties": {
+    "creative_id": {
+      "type": "string",
+      "minLength": 1,
+      "x-entity": "creative"
+    },
+    "revision_id": { "$ref": "/schemas/core/creative-revision-id.json" },
+    "revision_content_digest": {
+      "type": "string",
+      "pattern": "^sha256:[a-f0-9]{64}$",
+      "description": "Verified digest from the complete source representation set. A downstream seller uses this value, not the selected manifest bytes alone, to enforce immutable revision reuse."
+    },
+    "selected_representation_id": { "type": "string", "minLength": 1, "x-entity": "creative_representation" },
+    "strategy": {
+      "$ref": "/schemas/enums/representation-selection-strategy.json",
+      "description": "Deterministic strategy applied after compatibility filtering."
+    },
+    "selected_output_digest": {
+      "type": "string",
+      "pattern": "^sha256:[a-f0-9]{64}$",
+      "description": "Digest of the derived seller-bound manifest projection, computed with RFC 8785 JCS after removing exactly top-level `$schema`, `representation_selection`, `creative_id`, `revision_id`, `name`, `tags`, `status`, `weight`, `placement_refs`, `placement_ids`, and `inputs`. Every other field, including unknown delivery fields, is included. The identical exclusion list applies to the returned CreativeManifest and its later CreativeAsset sync wrapper. A selected sync item cannot carry localization in this version. This is the review/execution fingerprint for the projection, distinct from revision_content_digest, which binds the complete source set."
+    },
+    "resolved_by": {
+      "type": "string",
+      "enum": ["buyer", "seller"],
+      "description": "Who performed deterministic compatibility resolution. A buyer may resolve locally from seller discovery. Seller resolution is valid only on the destination sales agent when it advertised representation_resolution; an independent creative agent cannot claim seller-bound compatibility."
+    }
+  },
+  "required": ["creative_id", "revision_id", "revision_content_digest", "selected_representation_id", "strategy", "selected_output_digest", "resolved_by"],
+  "additionalProperties": false
+}
diff --git a/static/schemas/source/core/requirements/url-asset-requirements.json b/static/schemas/source/core/requirements/url-asset-requirements.json
index dadfd1be34..a62fc976aa 100644
--- a/static/schemas/source/core/requirements/url-asset-requirements.json
+++ b/static/schemas/source/core/requirements/url-asset-requirements.json
@@ -33,7 +33,7 @@
     },
     "macro_support": {
       "type": "boolean",
-      "description": "Whether the URL supports macro substitution (e.g., ${CACHEBUSTER})"
+      "description": "Coarse slot gate for macro-bearing URLs. `false` is a hard prohibition on macro tokens. `true` permits tokens but does not prove any dialect semantic, resolver, context, or encoding capability; exact support comes from the selected format option's macro_resolution_capabilities."
     }
   },
   "additionalProperties": true
diff --git a/static/schemas/source/core/requirements/vast-asset-requirements.json b/static/schemas/source/core/requirements/vast-asset-requirements.json
index 9d3a8272e2..9382515f34 100644
--- a/static/schemas/source/core/requirements/vast-asset-requirements.json
+++ b/static/schemas/source/core/requirements/vast-asset-requirements.json
@@ -7,8 +7,21 @@
   "properties": {
     "vast_version": {
       "$ref": "/schemas/enums/vast-version.json",
-      "description": "Required VAST version"
+      "deprecated": true,
+      "description": "Deprecated one-element alias for `vast_versions`. Producers use either the singular legacy alias or the plural 3.2 field, never both."
+    },
+    "vast_versions": {
+      "type": "array",
+      "items": { "$ref": "/schemas/enums/vast-version.json" },
+      "minItems": 1,
+      "uniqueItems": true,
+      "description": "Accepted VAST version set for this asset requirement."
+    },
+    "media_file_requirements": {
+      "$ref": "/schemas/core/vast-media-file-requirements.json",
+      "description": "Technical acceptance constraints for the alternative MediaFile renditions in each applicable resolved InLine linear creative."
     }
   },
-  "additionalProperties": true
+  "additionalProperties": true,
+  "not": { "required": ["vast_version", "vast_versions"] }
 }
diff --git a/static/schemas/source/core/requirements/video-asset-requirements.json b/static/schemas/source/core/requirements/video-asset-requirements.json
index 9da0352c55..a1c4d219bf 100644
--- a/static/schemas/source/core/requirements/video-asset-requirements.json
+++ b/static/schemas/source/core/requirements/video-asset-requirements.json
@@ -59,7 +59,7 @@
     "max_file_size_kb": {
       "type": "integer",
       "minimum": 1,
-      "description": "Maximum file size in kilobytes"
+      "description": "Maximum file size, where 1 KB is exactly 1,000 bytes"
     },
     "min_bitrate_kbps": {
       "type": "integer",
diff --git a/static/schemas/source/core/vast-media-file-requirements.json b/static/schemas/source/core/vast-media-file-requirements.json
new file mode 100644
index 0000000000..c4de0a112a
--- /dev/null
+++ b/static/schemas/source/core/vast-media-file-requirements.json
@@ -0,0 +1,89 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/core/vast-media-file-requirements.json",
+  "title": "VAST MediaFile Requirements",
+  "description": "Technical acceptance requirements for the alternative `<MediaFile>` renditions in a resolved VAST `<InLine>` linear creative. A linear creative satisfies this object when at least one of its MediaFile elements satisfies every declared field; incompatible sibling renditions do not reject the creative. Omitted fields are governed by the enclosing format declaration's `technical_requirements_complete` assertion and MUST NOT be inferred from prose or implementation defaults. When a declared constraint cannot be proven from VAST metadata or safe inspection of the referenced media bytes, compatibility is undeclared rather than assumed. Container identity MUST come from authoritative metadata or byte inspection, never only a URI filename extension.",
+  "type": "object",
+  "properties": {
+    "delivery_methods": {
+      "type": "array",
+      "items": {
+        "$ref": "/schemas/enums/vast-media-delivery-method.json"
+      },
+      "minItems": 1,
+      "uniqueItems": true,
+      "description": "Accepted values of the required `MediaFile@delivery` attribute. `progressive` identifies a directly downloadable media file; `streaming` identifies a streaming media resource."
+    },
+    "mime_types": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*/[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*$"
+      },
+      "minItems": 1,
+      "uniqueItems": true,
+      "description": "Accepted MIME types from `MediaFile@type`, compared case-insensitively after trimming optional whitespace. Parameters are not accepted in this field. Examples: `video/mp4`, `video/webm`."
+    },
+    "containers": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^[a-z0-9][a-z0-9._+-]*$"
+      },
+      "minItems": 1,
+      "uniqueItems": true,
+      "description": "Accepted normalized container identifiers, such as `mp4`, `webm`, or `mpeg_ts`. A receiver MUST determine the container from authoritative metadata or safe byte inspection and MUST NOT guess it only from the media URI suffix."
+    },
+    "codecs": {
+      "type": "array",
+      "items": { "type": "string", "minLength": 1 },
+      "minItems": 1,
+      "uniqueItems": true,
+      "description": "Accepted codec identifiers for `MediaFile@codec`, using the codec syntax referenced by the applicable VAST version. A missing codec attribute does not satisfy a declared codec constraint unless safe inspection establishes the codec."
+    },
+    "min_width": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Minimum accepted `MediaFile@width` in pixels."
+    },
+    "max_width": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Maximum accepted `MediaFile@width` in pixels."
+    },
+    "min_height": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Minimum accepted `MediaFile@height` in pixels."
+    },
+    "max_height": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Maximum accepted `MediaFile@height` in pixels."
+    },
+    "min_bitrate_kbps": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Minimum accepted MediaFile bitrate in kilobits per second. A fixed `MediaFile@bitrate` must be at least this value. For adaptive/streaming media, the declared `MediaFile@minBitrate` must be at least this value. Safe byte inspection may establish the value when metadata is absent."
+    },
+    "max_bitrate_kbps": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Maximum accepted MediaFile bitrate in kilobits per second. A fixed `MediaFile@bitrate` must not exceed this value. For adaptive/streaming media, the declared `MediaFile@maxBitrate` must not exceed this value. Safe byte inspection may establish the value when metadata is absent."
+    },
+    "max_file_size_bytes": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Maximum accepted MediaFile size in exact bytes. `MediaFile@fileSize`, when present, is expressed in bytes; a receiver MAY verify it against safely fetched media bytes and MUST use the verified byte count if the values disagree."
+    }
+  },
+  "x-adcp-validation": {
+    "verifier_constraints": {
+      "range_order": "When both bounds are declared, min_width MUST be <= max_width, min_height MUST be <= max_height, and min_bitrate_kbps MUST be <= max_bitrate_kbps.",
+      "adaptive_bitrate_containment": "A MediaFile advertising a minBitrate/maxBitrate interval satisfies declared bitrate bounds only when its entire interval is contained within those bounds; overlap alone is insufficient.",
+      "alternative_renditions": "For each applicable resolved InLine linear creative, at least one MediaFile MUST satisfy every declared property in this object; requirements MUST NOT be satisfied by combining properties from different MediaFile elements.",
+      "missing_metadata": "If a declared property cannot be established from VAST metadata or safe inspection, compatibility is unproven and the MediaFile does not satisfy that property."
+    }
+  },
+  "additionalProperties": true
+}
diff --git a/static/schemas/source/core/x-entity-types.json b/static/schemas/source/core/x-entity-types.json
index 3129b1fc34..0c635d56c6 100644
--- a/static/schemas/source/core/x-entity-types.json
+++ b/static/schemas/source/core/x-entity-types.json
@@ -20,11 +20,15 @@
     "product_pricing_option",
     "vendor_pricing_option",
     "creative",
+    "creative_revision",
+    "creative_representation",
+    "macro_declaration",
     "creative_locale_variant",
     "creative_format",
     "transformer",
     "evaluator",
     "build_variant",
+    "served_variant",
     "audience",
     "audience_evidence",
     "audience_evidence_snapshot",
@@ -75,11 +79,15 @@
     "product_pricing_option": "A pricing tier on a seller's inventory product (CPM / CPC / CPCV / etc). `pricing_option_id` inside `core/package.json` and `media-buy/package-request.json`. Scoped to the seller's product rate card — not interchangeable with `vendor_pricing_option`.",
     "vendor_pricing_option": "A pricing tier offered by a vendor agent (rights agent, signals agent, creative agent, governance agent) for its own services. `pricing_option_id` via `core/vendor-pricing-option.json`, also surfaced in `brand/acquire-rights-*`, `signals/activate-signal-request`, `media-buy/build-creative-response`, and `creative/get-creative-features-response`. Scoped to the issuing agent; not interchangeable with `product_pricing_option`.",
     "creative": "A creative asset (library entry, buyer-assigned). `creative_id` across creative/*, brand/creative-approval-*, and media-buy/package-request.",
+    "creative_revision": "A buyer-assigned immutable input-content state beneath one durable creative. Identity is the tuple `(creative_id, revision_id)`. `revision_id` round-trips through sync_creatives, list_creatives, creative status webhooks, and delivery readback. Seller transcoding, normalization, and alternate delivery representations do not create a new revision.",
+    "creative_representation": "One equivalent trafficking representation inside a complete creative representation set. `representation_id` is scoped to the parent creative revision and is echoed in selection and rejection results. Selecting, transcoding, or delivering one representation does not mint a new buyer revision or reuse a served variant identity.",
+    "macro_declaration": "One occurrence-level macro processing declaration within a creative asset. `declaration_id` in core/macro-declaration.json is echoed by core/macro-resolution-result.json so validation and sync results correlate to the exact declared occurrence. Scoped to the enclosing asset and not globally unique.",
     "creative_locale_variant": "A buyer-assigned stable locale execution within one localized creative. `locale_variant_id` round-trips from core/creative-localization.json into sync_creatives and list_creatives readback, then attributes localized executions in get_creative_delivery. Scoped to the parent creative and deliberately distinct from build_variant (a build_creative output leaf) and variant_id (a provider execution observed in reporting).",
     "creative_format": "A format spec identified by the composite of `agent_url` + `id` (see core/format-id.json).",
     "transformer": "An account-scoped creative build capability offered by a creative agent (the creative analog of a product) — a voice, model, style, or director with typed config params and per-account pricing. `transformer_id` via `core/transformer.json`, discovered in `creative/list-transformers-response` and selected in `media-buy/build-creative-request`. Scoped to the issuing creative agent.",
     "evaluator": "An account-scoped house evaluator preset a buyer attaches to `build_creative` to rank best_of_n variants - the rank-side of the get_creative_features feature oracle. `evaluator_id` on `core/evaluator-spec.json`, selected in `media-buy/build-creative-request`. The evaluator_id itself is pre-provisioned/account-arranged; only the feature vocabulary it emits is discovered via get_adcp_capabilities governance.creative_features. Scoped to the issuing creative agent.",
     "build_variant": "A single produced creative variant leaf from build_creative — the leaf-level lineage anchor. `build_variant_id` on `media-buy/build-creative-response` BuildCreativeVariantSuccess `creatives[].variants[]`. Distinct from a served `variant_id` (delivery) and a `preview_id` (preview renders), and distinct from the call-level grouping `build_creative_id`. On the canonical promotion path, the kept build_variant_id becomes the durable creative_id; delivery joins then use creative_id.",
+    "served_variant": "An agent-assigned immutable creative execution observed in delivery reporting. `variant_id` is unique within the issuing agent and round-trips from get_creative_delivery into preview_creative variant replay when that capability is supported. A distinct source revision, locale, or rendered manifest receives a distinct AdCP variant_id even when the underlying ad platform reuses a native identifier. Distinct from build_variant, creative_revision, and creative_locale_variant.",
     "audience": "A buyer-managed audience (CRM, lookalike seed, suppression). `audience_id` in media-buy/sync-audiences-request.",
     "audience_evidence": "A provider-scoped logical series of population-level audience evidence. `evidence_id` in core/audience-evidence.json and core/audience-evidence-selection.json remains stable while immutable snapshots receive distinct snapshot ids and content digests.",
     "audience_evidence_snapshot": "An immutable seller-scoped audience-evidence snapshot. `snapshot_id` in core/audience-evidence.json and core/audience-evidence-selection.json MUST never be reused for different canonical evidence content.",
diff --git a/static/schemas/source/creative/creative-status-changed-webhook.json b/static/schemas/source/creative/creative-status-changed-webhook.json
index 80779971ea..fa01df7578 100644
--- a/static/schemas/source/creative/creative-status-changed-webhook.json
+++ b/static/schemas/source/creative/creative-status-changed-webhook.json
@@ -46,6 +46,22 @@
       "description": "Seller's identifier for the creative whose status changed. References the same id space as `list_creatives` / `sync_creatives` responses.",
       "x-entity": "creative"
     },
+    "revision_id": {
+      "$ref": "/schemas/core/creative-revision-id.json",
+      "description": "Buyer-authored input revision to which this transition applies. Required when the reviewed state has revision identity and the seller advertises creative.supports_revisions; it need not be the current list revision when the fire is received. Omitted for unversioned current content. A stale review outcome MUST NOT emit a fire as though it applied to a newer current revision.",
+      "x-adcp-validation": {
+        "verifier_constraints": {
+          "revision_transition_attribution": {
+            "required_capability": "creative.supports_revisions",
+            "required_when_transition_applies_to_bound_revision": true,
+            "must_equal": "revision_to_which_transition_applies",
+            "omit_for_unversioned_content": true,
+            "stale_result_must_not_target_current_revision": true
+          }
+        },
+        "spec": "docs/creative/specification.mdx#lifecycle-webhooks"
+      }
+    },
     "transition": {
       "type": "object",
       "description": "The status transition that triggered this fire. Valid `from` values are restricted to the prior states from which a seller/system-initiated transition can fire (`processing` for processing outcomes, `pending_review` for initial review outcomes, `approved` for re-review/revocation/seller-archive/recoverable suspension, `suspended` for seller-observed recovery or terminal escalation). The post-terminal states `rejected` and `archived` MUST NOT appear as `from` — those would require a buyer-initiated unblock (`sync_creatives` resubmit / unarchive), which does not fire this event.",
diff --git a/static/schemas/source/creative/get-creative-delivery-response.json b/static/schemas/source/creative/get-creative-delivery-response.json
index ce3bde9537..092d3b6e7a 100644
--- a/static/schemas/source/creative/get-creative-delivery-response.json
+++ b/static/schemas/source/creative/get-creative-delivery-response.json
@@ -88,14 +88,32 @@
           },
           "variant_count": {
             "type": "integer",
-            "description": "Total number of variants for this creative. When max_variants was specified in the request, this may exceed the number of items in the variants array.",
+            "description": "Total number of agent-unique variant_id rows for this creative. When max_variants was specified in the request, this may exceed the number of items in the variants array.",
             "minimum": 0
           },
           "variants": {
             "type": "array",
-            "description": "Variant-level delivery breakdown. Each variant includes the rendered manifest and delivery metrics. For standard creatives, contains a single variant. For asset group optimization, one per combination. For generative creative, one per generated execution. Empty when a creative has no variants yet.",
+            "description": "Variant-level delivery breakdown. Each agent-unique variant_id identifies one immutable served execution and each row includes metrics from exactly one source revision and, for localized delivery, exactly one locale variant. A distinct revision, locale, or rendered manifest receives a distinct variant_id; metrics MUST NOT cross those boundaries. For standard creatives, contains one row per source revision and locale represented in the reporting period. For asset group optimization, one per combination, source revision, and locale. For generative creative, one per generated execution, source revision, and locale. Empty when a creative has no variants yet.",
             "items": {
               "$ref": "/schemas/core/creative-variant.json"
+            },
+            "x-adcp-validation": {
+              "verifier_constraints": {
+                "revision_homogeneous_rows": {
+                  "row_key": ["variant_id"],
+                  "row_key_unique": true,
+                  "variant_id_scope": {
+                    "default": "unique_within_agent_and_creative",
+                    "when_creative_supports_revisions": "agent_unique_immutable_and_unambiguous_for_variant_preview_when_supported"
+                  },
+                  "native_identifier_reuse": "map_each_distinct_revision_locale_or_rendered_execution_to_a_distinct_adcp_variant_id",
+                  "metrics_must_not_cross_revision_boundary": true,
+                  "metrics_must_not_cross_locale_boundary": true,
+                  "locale_variant_membership": "source_revision_localization_topology",
+                  "variant_count": "count_distinct_row_keys_before_max_variants_limit"
+                }
+              },
+              "spec": "docs/creative/task-reference/get_creative_delivery.mdx#revision-attribution"
             }
           }
         },
diff --git a/static/schemas/source/creative/list-creatives-response.json b/static/schemas/source/creative/list-creatives-response.json
index 8cf24590d2..c305249dec 100644
--- a/static/schemas/source/creative/list-creatives-response.json
+++ b/static/schemas/source/creative/list-creatives-response.json
@@ -67,6 +67,35 @@
             "description": "Unique identifier for the creative",
             "x-entity": "creative"
           },
+          "revision_id": {
+            "$ref": "/schemas/core/creative-revision-id.json",
+            "description": "Current buyer-authored input revision for this creative. Present when the current effective content has revision identity and the seller advertises creative.supports_revisions; omitted after an accepted content-bearing legacy update without revision_id.",
+            "x-adcp-validation": {
+              "verifier_constraints": {
+                "revision_readback": {
+                  "required_capability": "creative.supports_revisions",
+                  "required_when_current_revision_is_bound": true,
+                  "must_equal": "last_accepted_current_buyer_revision",
+                  "omit_when_current_content_is_unversioned": true
+                }
+              },
+              "spec": "docs/creative/task-reference/list_creatives.mdx#per-creative-fields"
+            }
+          },
+          "representation_selection": {
+            "$ref": "/schemas/core/representation-selection.json",
+            "description": "Exact source-set and selected-output lineage retained when the current stored creative was resolved from a CreativeRepresentationSet.",
+            "x-adcp-validation": {
+              "verifier_constraints": {
+                "representation_lineage_readback": {
+                  "required_when_current_creative_was_resolved_from_representation_set": true,
+                  "must_equal": "last_accepted_current_representation_selection",
+                  "historical_selection_not_substituted": true
+                }
+              },
+              "spec": "docs/creative/representation-sets.mdx#sync-review-and-readback"
+            }
+          },
           "account": {
             "$ref": "/schemas/core/account.json",
             "description": "Account that owns this creative"
diff --git a/static/schemas/source/creative/preview-creative-request.json b/static/schemas/source/creative/preview-creative-request.json
index fa9d6dc888..1a91068a82 100644
--- a/static/schemas/source/creative/preview-creative-request.json
+++ b/static/schemas/source/creative/preview-creative-request.json
@@ -256,7 +256,8 @@
     },
     "variant_id": {
       "type": "string",
-      "description": "Platform-assigned variant identifier from get_creative_delivery response. Required when request_type is 'variant'."
+      "description": "Agent-assigned AdCP served-execution identifier from get_creative_delivery. Required when request_type is 'variant'. It is agent-unique when the source agent advertises creative.supports_revisions; for legacy agents the published scope remains agent plus creative, and callers SHOULD also send creative_id to disambiguate reused values.",
+      "x-entity": "served_variant"
     },
     "creative_id": {
       "type": "string",
diff --git a/static/schemas/source/creative/preview-creative-response.json b/static/schemas/source/creative/preview-creative-response.json
index 98189895a1..5bada82d81 100644
--- a/static/schemas/source/creative/preview-creative-response.json
+++ b/static/schemas/source/creative/preview-creative-response.json
@@ -284,7 +284,8 @@
         },
         "variant_id": {
           "type": "string",
-          "description": "Platform-assigned variant identifier"
+          "description": "Agent-assigned AdCP served-execution identifier. Agent-unique for an agent advertising creative.supports_revisions; otherwise scoped by this response's creative_id.",
+          "x-entity": "served_variant"
         },
         "creative_id": {
           "type": "string",
diff --git a/static/schemas/source/creative/sync-creatives-request.json b/static/schemas/source/creative/sync-creatives-request.json
index 0735a84aba..1faa91ce64 100644
--- a/static/schemas/source/creative/sync-creatives-request.json
+++ b/static/schemas/source/creative/sync-creatives-request.json
@@ -51,6 +51,10 @@
           {
             "type": "object",
             "properties": {
+              "revision_id": {
+                "$ref": "/schemas/core/creative-revision-id.json",
+                "description": "Optional buyer-assigned identity for this exact input-content state. Buyers may send it to any 3.2 peer; creative.supports_revisions gates reliance on immutability, echo, readback, and delivery correlation, not whether the open request shape may carry the field. Within a supporting seller, a revision_id is immutable under one creative_id: reusing it with different canonical revision content MUST fail with CREATIVE_REVISION_CONTENT_MISMATCH. Metadata and assignment fields excluded from revision content may change without minting a new revision."
+              },
               "localization": {
                 "description": "Sync-only materialized-localization mutation. The top-level assets are the source variant; optional locale_fallbacks declare buyer-approved language-family substitutions, and default_locale_variant_id selects the final serving fallback. An object transactionally replaces the source assets and complete locale set, omission preserves existing localization only when the top-level source assets are unchanged, and null removes localization. This field never requests translation or generation. Receivers MUST advertise get_adcp_capabilities creative.localization before accepting it.",
                 "anyOf": [
@@ -59,7 +63,90 @@
                 ]
               }
             },
-            "additionalProperties": true
+            "additionalProperties": true,
+            "x-adcp-validation": {
+              "verifier_constraints": {
+                "revision_identity": {
+                  "reliance_gate": "creative.supports_revisions",
+                  "without_capability": "receiver_may_ignore_revision_id_and_buyer_must_not_rely_on_revision_guarantees",
+                  "scope": ["creative_id", "revision_id"],
+                  "check_order": ["idempotency_key", "revision_content"],
+                  "canonical_content": {
+                    "included": "all effective buyer-authored creative fields, including unknown future content fields",
+                    "mutation_projection": "apply_existing_sync_field_semantics_to_prior_buyer_state_before_comparison",
+                    "localization_omitted": "preserve_prior_localization_before_comparison_when_existing_localized_source_upsert_allows_omission",
+                    "localization_null": "remove_localization_property_from_effective_state_before_comparison",
+                    "canonicalization": "RFC_8785_JCS_of_effective_buyer_state_after_removing_exact_top_level_excluded_fields",
+                    "defaults": "must_not_be_materialized_before_comparison",
+                    "duplicate_json_members": "reject_request_before_comparison",
+                    "excluded": [
+                      "creative_id",
+                      "revision_id",
+                      "name",
+                      "tags",
+                      "status",
+                      "weight",
+                      "placement_refs",
+                      "placement_ids"
+                    ],
+                    "exclusion_scope": "top_level_creative_item_only",
+                    "evaluated_before": "seller_transcoding_or_normalization"
+                  },
+                  "representation_set_projection": {
+                    "when": "creative item carries representation_selection",
+                    "identity_match": "item creative_id and revision_id MUST equal representation_selection creative_id and revision_id",
+                    "source_revision_binding": "use representation_selection.revision_content_digest as the complete representation-set fingerprint; MUST NOT fingerprint only the selected manifest as the source revision",
+                    "selected_output_verification": "recompute representation_selection.selected_output_digest with the shared manifest projection: remove exactly top-level $schema, representation_selection, creative_id, revision_id, name, tags, status, weight, placement_refs, placement_ids, and inputs; include every other field, including unknown delivery fields",
+                    "execution_review_binding": "track selected_representation_id plus selected_output_digest separately from the source revision fingerprint",
+                    "execution_change": "a different selected_representation_id or selected_output_digest is an updated execution and follows ordinary re-review without minting a new buyer revision_id",
+                    "explicit_reselection": "only a buyer-submitted sync_creatives item carrying a newly resolved selected output may replace accepted representation_selection lineage and trigger re-review; build_creative resolution alone does not mutate the creative library",
+                    "capability_drift": "later product, placement, VAST, macro, or seller-capability changes affect future resolution and assignment validation but MUST NOT implicitly re-resolve, replace lineage, or start buyer re-review for an accepted execution",
+                    "seller_inability": "when a pinned execution can no longer serve, preserve its selection lineage and use ordinary seller/system creative-status and media-buy impairment surfaces; MUST NOT silently substitute another representation",
+                    "resolver_obligation": "the actor that emitted representation_selection MUST have verified the digest against the complete CreativeRepresentationSet",
+                    "downstream_obligation": "retain and compare the complete-set digest for revision reuse; receiving only a selected manifest does not independently prove hidden source-set bytes"
+                  },
+                  "same_revision_same_content": "unchanged_unless_metadata_changed",
+                  "same_revision_different_content": "CREATIVE_REVISION_CONTENT_MISMATCH",
+                  "first_revision_on_unversioned_creative": {
+                    "same_effective_content": "accept_as_updated_bind_revision_and_preserve_review_state",
+                    "different_effective_content": "bind_only_on_accepted_update_and_require_review"
+                  },
+                  "different_revision_same_current_content": "accept_as_updated_make_current_preserve_review_state_and_rebind_inflight_review",
+                  "previously_bound_revision_matching_historical_content": "accept_as_updated; require_review_if_content_differs_from_current",
+                  "different_revision_different_content": "accept_as_updated_make_current_and_require_review",
+                  "revision_omitted_with_current_revision": {
+                    "same_effective_content": "preserve_current_revision_identity",
+                    "different_effective_content": "accept_under_legacy_update_rules_and_clear_current_revision_identity",
+                    "different_effective_content_review": "prior_approval_must_not_transfer_and_update_enters_ordinary_review",
+                    "must_not_mint_seller_revision": true,
+                    "historical_fingerprint_bindings": "retain"
+                  },
+                  "content_change_review": "prior_approval_must_not_transfer",
+                  "write_order": "last_accepted_sync_wins_callers_must_serialize_revision_writes",
+                  "stale_review_result": {
+                    "different_fingerprint_or_not_rebound": "must_not_mutate_current_revision_or_current_status",
+                    "identical_content_rebound": "apply_to_current_revision_and_attribute_result_and_webhook_to_current_revision_id"
+                  },
+                  "dry_run": "evaluate_against_existing_bindings_and_echo_simulated_result_but_do_not_create_or_update_bindings_tombstones_current_revision_or_review_state",
+                  "fingerprint_retention": "retain_for_creative_lifetime_and_soft_purge_tombstone_lifetime; hard_purge_removes_binding"
+                }
+              },
+              "spec": "docs/creative/task-reference/sync_creatives.mdx#creative-revisions"
+            }
+          },
+          {
+            "$comment": "Representation-set selection and sync-time localization use different revision projections and cannot be mixed in this version.",
+            "if": { "required": ["representation_selection"] },
+            "then": {
+              "not": { "required": ["localization"] },
+              "x-adcp-validation": {
+                "verifier_constraints": {
+                  "prior_stored_localization": "must_be_absent",
+                  "on_existing_localization": "reject_before_mutation_and_require_a_separate_prior_sync_with_localization_null_and_without_representation_selection"
+                },
+                "spec": "docs/creative/representation-sets.mdx#sync-review-and-readback"
+              }
+            }
           }
         ],
         "x-adcp-validation": {
@@ -85,7 +172,11 @@
         }
       },
       "minItems": 1,
-      "maxItems": 100
+      "maxItems": 100,
+      "x-adcp-validation": {
+        "unique_item_properties": ["creative_id"],
+        "spec": "docs/creative/task-reference/sync_creatives.mdx#request-parameters"
+      }
     },
     "creative_ids": {
       "type": "array",
diff --git a/static/schemas/source/creative/sync-creatives-response.json b/static/schemas/source/creative/sync-creatives-response.json
index 3c21fcc29e..0f04f2ea54 100644
--- a/static/schemas/source/creative/sync-creatives-response.json
+++ b/static/schemas/source/creative/sync-creatives-response.json
@@ -33,6 +33,10 @@
                 "description": "Creative ID from the request",
                 "x-entity": "creative"
               },
+              "revision_id": {
+                "$ref": "/schemas/core/creative-revision-id.json",
+                "description": "Exact revision_id from the matching request creative. When the agent advertises creative.supports_revisions, required for accepted created, updated, or unchanged items whose request supplied revision_id. A peer without that capability may ignore the request field. Forbidden on failed or deleted items."
+              },
               "account": {
                 "$ref": "/schemas/core/account.json",
                 "description": "Account that owns this creative"
@@ -95,6 +99,11 @@
                   "type": "string"
                 }
               },
+              "macro_resolution_results": {
+                "type": "array",
+                "items": { "$ref": "/schemas/core/macro-resolution-result.json" },
+                "description": "Per-token result for declared macros. Sellers include this on accepted items when macro declarations were evaluated, and may include it alongside a failed item's structured errors."
+              },
               "preview_url": {
                 "type": "string",
                 "format": "uri",
@@ -148,7 +157,8 @@
                   "not": {
                     "anyOf": [
                       { "required": ["status"] },
-                      { "required": ["localization"] }
+                      { "required": ["localization"] },
+                      { "required": ["revision_id"] }
                     ]
                   }
                 }
@@ -160,6 +170,22 @@
                 "then": {
                   "required": ["status"]
                 }
+              },
+              {
+                "x-adcp-validation": {
+                  "verifier_constraints": {
+                    "revision_echo": {
+                      "required_capability": "creative.supports_revisions",
+                      "request_match_key": "creative_id",
+                      "request_field": "revision_id",
+                      "accepted_actions": ["created", "updated", "unchanged"],
+                      "required_when_request_field_present": true,
+                      "must_equal_request": true,
+                      "forbidden_actions": ["failed", "deleted"]
+                    }
+                  },
+                  "spec": "docs/creative/task-reference/sync_creatives.mdx#creative-revisions"
+                }
               }
             ]
           }
diff --git a/static/schemas/source/creative/validate-input-result.json b/static/schemas/source/creative/validate-input-result.json
index ce86c2655f..bd6e6060c8 100644
--- a/static/schemas/source/creative/validate-input-result.json
+++ b/static/schemas/source/creative/validate-input-result.json
@@ -82,6 +82,11 @@
         },
         "additionalProperties": true
       }
+    },
+    "macro_resolution_results": {
+      "type": "array",
+      "items": { "$ref": "/schemas/core/macro-resolution-result.json" },
+      "description": "Per-token compatibility against the selected target. Required or unsafe `unsupported`/`ambiguous` results make the target `validated_fail`; deliberate preservation for the declared downstream resolver may still pass."
     }
   },
   "allOf": [
diff --git a/static/schemas/source/enums/error-code.json b/static/schemas/source/enums/error-code.json
index bbbe99b33a..68200062d1 100644
--- a/static/schemas/source/enums/error-code.json
+++ b/static/schemas/source/enums/error-code.json
@@ -21,6 +21,7 @@
     "CREATIVE_REJECTED",
     "CREATIVE_LOCALE_NOT_ACCEPTED",
     "CREATIVE_VALUE_NOT_ALLOWED",
+    "CREATIVE_REVISION_CONTENT_MISMATCH",
     "UNSUPPORTED_FEATURE",
     "UNPRICEABLE_OUTPUT",
     "UNSUPPORTED_GRANULARITY",
@@ -114,7 +115,9 @@
     "SIGNED_RESPONSE_TENANT_MISMATCH",
     "VAST_PARSE_FAILED",
     "VAST_VERSION_MISMATCH",
-    "VAST_WRAPPER_DEPTH_EXCEEDED"
+    "VAST_WRAPPER_DEPTH_EXCEEDED",
+    "CREATIVE_REPRESENTATION_UNRESOLVED",
+    "MACRO_RESOLUTION_FAILED"
   ],
   "enumDescriptions": {
     "INVALID_REQUEST": "Request is malformed, missing required fields, or violates schema constraints. Recovery: correctable (check request parameters and fix).",
@@ -133,6 +136,7 @@
     "CREATIVE_REJECTED": "Creative failed content-policy, brand-safety, or accessibility review. For deadline violations, see CREATIVE_DEADLINE_EXCEEDED. Accessibility failures SHOULD use structured details conforming to error-details/accessibility-violation.json. Recovery: correctable (revise the creative according to the applicable policy or validated accessibility criteria).",
     "CREATIVE_LOCALE_NOT_ACCEPTED": "A creative bound to a locale-constrained product format has no materialized variant matching locale_policy.accepted_language_ranges, lacks protocol-declared locale topology, or uses serve_default with a seller-ineligible default variant. Seller ranges use RFC 4647 Basic Filtering and are applied independently for every placement where the assignment may serve, before buyer Lookup, locale_fallbacks, or default selection. Distinct from CREATIVE_REJECTED because this is a mechanically discoverable assignment-eligibility mismatch, not subjective content review. error.field SHOULD point to the offending creative or assignment; error.details SHOULD include format_option_id when present, accepted_language_ranges, available_variant_locales, and placement identity when applicable. Recovery: correctable (supply or assign a matching materialized locale variant, narrow placement scope, choose a compatible format option, or change an ineligible serve_default).",
     "CREATIVE_VALUE_NOT_ALLOWED": "A submitted text-asset value is not in the format's declared `allowed_values` list. Distinct from `CREATIVE_REJECTED` (generic creative-review failure) by being a closed-set constraint violation that the buyer can resolve mechanically without policy interpretation — the seller has published the complete list of acceptable values on the format, and any value outside that list is rejected by definition. The seller MUST set `error.field` to the offending asset's path within the manifest (e.g., `creatives[0].creative_manifest.assets[0].value` or the field name declared by the format) and SHOULD include the format's `allowed_values` array in `error.details.allowed_values` so the buyer agent can re-prompt its LLM with constrained sampling. Recovery: correctable (select a value from `allowed_values` and resubmit).",
+    "CREATIVE_REVISION_CONTENT_MISMATCH": "A sync_creatives item reused a revision_id for different canonical revision content under the same creative_id. Revision identity is scoped to the parent creative and immutable after first acceptance. Sellers MUST evaluate the buyer input before transcoding or normalization, MUST leave the prior creative state unchanged, and SHOULD return details conforming to error-details/creative-revision-content-mismatch.json. Distinct from IDEMPOTENCY_CONFLICT: idempotency_key protects one request replay window, while revision identity protects creative content across requests and retention. Recovery: correctable (resend the exact content previously bound to this revision_id, or mint a new revision_id for the changed content).",
     "UNSUPPORTED_FEATURE": "A requested feature or field is not supported by this seller. When rejecting a `refine_proposals` request that uses a typed dimension omitted from an explicit `proposal_refinement.supported_dimensions` declaration, the error details SHOULD follow `error-details/unsupported-refinement-dimension.json` — `unsupported_dimension` names the offending dimension and `supported_dimensions` echoes the seller's declaration so the buyer can remove or translate the field without another capability round trip. Recovery: correctable (check get_adcp_capabilities and remove unsupported fields).",
     "UNPRICEABLE_OUTPUT": "A creative transformer build targets an output capability that no pricing option covers — no transformer.pricing_options entry has a matching applies_to_output_capability_ids and none is unscoped. The build is rejected rather than billed at a guessed rate. Recovery: correctable.",
     "UNSUPPORTED_GRANULARITY": "The requested `time_granularity` on `get_media_buy_delivery` is not in the product's declared `reporting_capabilities.windowed_pull_granularities`. Distinct from `UNSUPPORTED_FEATURE` (generic capability mismatch) by being narrowly about reporting-window granularity — the buyer asked for hourly pull-recovery on a product that only honors daily pulls, for example. Sellers MAY echo the declared set in `error.details.supported_granularities` when the caller is authorized to read the product's reporting capabilities — the same set is already available via `get_adcp_capabilities`, so the echo is a convenience, not load-bearing. Sellers MUST NOT echo a granularity set the caller could not otherwise read (per-product capability views vary by buyer entitlement). The `error.field` SHOULD point at `time_granularity`. Buyers that need higher-frequency recovery than the seller's pull set supports MUST rely on the webhook channel as primary at that frequency — the seller's `available_reporting_frequencies` may legitimately exceed `windowed_pull_granularities` (e.g., a stream-tap webhook on Kafka with warehouse pulls only at daily). Recovery: correctable (re-issue at a granularity in the declared set, or omit `time_granularity` to fall back to cumulative date-range pulls).",
@@ -225,8 +229,10 @@
     "SIGNED_RESPONSE_REQUEST_HASH_MISMATCH": "The `signed_response.payload.request_hash` does not match the verifier's recomputed SHA-256 hash of the canonical request-binding object `{ task, brand_domain, agent_url, caller_identity, request }` for the actual request sent. Raised during step 8 of the [response-signing verifier checklist](/docs/building/by-layer/L1/security#verifier-checklist-responses). This indicates either a replay of a signed response from a different request, a JCS request-binding canonicalization divergence between signer and verifier, or payload tampering. Verifiers MUST reject the envelope when the recomputed hash does not byte-match the signed `request_hash`. `error.details` SHOULD carry `expected_request_hash` (the verifier's recomputed value) when safe to disclose — the hash binds the response to the exact request that produced it, and divergence is the signal that the binding has been broken. Recovery: correctable (re-invoke the designated task with the intended request parameters; if the mismatch persists across retries, investigate JCS request-binding canonicalization between the caller and the responding agent).",
     "SIGNED_RESPONSE_TENANT_MISMATCH": "The `signed_response.payload.brand_domain` does not match the verifier's resolved or expected brand tenant for this verification call. Raised during step 9 of the [response-signing verifier checklist](/docs/building/by-layer/L1/security#verifier-checklist-responses). The responding brand agent derives `brand_domain` from server-side tenant resolution, not from caller-supplied request fields (per the response-signing profile in security.mdx), so a mismatch indicates cross-tenant replay, a multi-brand agent routing error, or a mismatch between the verifier's tenant resolution and the responder's. Distinct from `SIGNED_RESPONSE_REQUEST_HASH_MISMATCH` (request-binding divergence) by being narrowly about the tenant identity — `brand_domain` is a field inside the signed payload that the responder derives independently, not an echo of any caller-supplied value. Recovery: correctable (verify that the request targeted the correct brand domain and agent; re-invoke with the correct brand reference if the request was mis-routed; if the mismatch persists, the responding agent's server-side tenant resolution may be misconfigured).",
     "VAST_PARSE_FAILED": "A submitted `vast` asset failed document-level validation: the inline `content` (or the document fetched from `url`) is not well-formed XML, has no `<VAST>` root element, contains no `<Ad>` element, or an `<InLine>` linear creative carries no `<MediaFile>`. Returned by sellers that declare `creative_specs.vast_validation` of `document` or `wrapper`; sellers at the default `structural` level do not inspect the VAST document and MUST NOT return this code. Distinct from `VALIDATION_ERROR` (manifest-level format validation): the manifest was structurally valid, the VAST document inside it was not. Sellers SHOULD set `error.field` to the offending asset path and SHOULD populate `error.details.reason` with one of `not_xml`, `no_vast_root`, `no_ad`, `no_media_file`. Unresolved ad-server macros in URLs (`[MACRO]`, `${MACRO}`, `{UNIVERSAL_MACRO}`) are opaque tokens, not parse failures. Recovery: correctable (fix the VAST document and resubmit).",
-    "VAST_VERSION_MISMATCH": "A submitted `vast` asset's document declares a `<VAST version>` attribute that does not match the asset's declared `vast_version`, does not satisfy the format's `vast_version` requirement, or is not in the seller's declared `creative_specs.vast_versions`. Returned by sellers performing document-level VAST validation (`creative_specs.vast_validation` of `document` or `wrapper`). Distinct from `VERSION_UNSUPPORTED` (AdCP protocol version negotiation, unrelated to creative documents). Sellers SHOULD set `error.field` to the offending asset path and SHOULD include the accepted versions in `error.details.supported_versions`. Recovery: correctable (re-tag with an accepted VAST version, or correct the asset's declared `vast_version`).",
-    "VAST_WRAPPER_DEPTH_EXCEEDED": "Resolving a `vast` asset's wrapper chain failed: the chain exceeded the format's declared `max_wrapper_depth`, revisited a `VASTAdTagURI` already seen in the chain (a loop), or a hop did not resolve within the seller's per-hop timeout. Returned by sellers that declare `creative_specs.vast_validation: \"wrapper\"`. Sellers SHOULD set `error.field` to the offending asset path and SHOULD populate `error.details.reason` with one of `depth`, `loop`, `timeout`, plus `error.details.depth` with the depth reached. Recovery: correctable (flatten the chain, reduce redirects below the format's `max_wrapper_depth`, or fix the failing hop)."
+    "VAST_VERSION_MISMATCH": "A submitted `vast` asset is version-incompatible when its exact `vast_version` is absent from the intersection of the selected product format option's `params.vast_versions` and the seller's `execution.creative_specs.vast_versions`, or when an inspected document violates its applicable VAST version rule. Modern `error.details` MUST conform to `error-details/vast-version-mismatch.json`: acceptance failures carry `mismatch_reason: asset_outside_acceptance`, `asset_vast_version`, `product_vast_versions`, and `seller_vast_versions`, plus `format_option_ref` only when the selected option is addressable; inspected-document failures carry `mismatch_reason: document_version_mismatch`, `asset_vast_version`, `observed_document_vast_version`, and `document_role`. Only the submitted document is compared for equality with the asset declaration; wrapper and terminal documents are checked against the acceptance intersection. The deprecated `supported_versions` field remains accepted for older 3.x peers. Distinct from `VERSION_UNSUPPORTED`, which concerns AdCP protocol negotiation. Recovery: correctable (select a source VAST representation in the compatibility intersection or correct the offending document; never relabel the asset).",
+    "VAST_WRAPPER_DEPTH_EXCEEDED": "Resolving a `vast` asset's wrapper chain failed: the chain exceeded the format's declared `max_wrapper_depth`, revisited a `VASTAdTagURI` already seen in the chain (a loop), or a hop did not resolve within the seller's per-hop timeout. Returned by sellers that declare `creative_specs.vast_validation: \"wrapper\"`. Sellers SHOULD set `error.field` to the offending asset path and SHOULD populate `error.details.reason` with one of `depth`, `loop`, `timeout`, plus `error.details.depth` with the depth reached. Recovery: correctable (flatten the chain, reduce redirects below the format's `max_wrapper_depth`, or fix the failing hop).",
+    "CREATIVE_REPRESENTATION_UNRESOLVED": "No representation in a CreativeRepresentationSet is compatible with the selected target capability or product format option. The resolver MUST retain the complete representation set and MUST include one `error.details.representation_rejections[]` entry per candidate, conforming to `error-details/creative-representation-unresolved.json`; silent seller guessing is forbidden. Recovery: correctable (choose a compatible product/format option, add a compatible representation under a new revision, or fix the rejected asset contract).",
+    "MACRO_RESOLUTION_FAILED": "One or more declared creative macro tokens cannot be resolved or safely preserved under the selected product and seller capability intersection. Sellers MUST include per-token `error.details.macro_resolution_results`, conforming to `error-details/macro-resolution-failed.json`; unknown or ambiguous tokens remain byte-preserved and MUST NOT receive guessed values. Recovery: correctable (route to a compatible execution path, correct the verified declaration, or assign the proper downstream resolver)."
   },
   "enumMetadata": {
     "$comment": "Structured recovery classification and remediation hints for each error code. SDKs MUST consume this block instead of parsing 'Recovery: X' from enumDescriptions prose. Each entry is { recovery, suggestion }. recovery is one of: correctable (caller can fix and retry), transient (retry with backoff), terminal (no autonomous recovery - operator intervention required). enumDescriptions is retained for human readability and will continue to carry the canonical narrative; the recovery classification embedded in that prose is normative and MUST match the value here.",
@@ -390,6 +396,10 @@
       "recovery": "correctable",
       "suggestion": "verify the asset URLs in creative_manifest are reachable without agent-side credentials, then re-submit"
     },
+    "CREATIVE_REVISION_CONTENT_MISMATCH": {
+      "recovery": "correctable",
+      "suggestion": "resend the exact content previously bound to this revision_id, or mint a new revision_id for changed content"
+    },
     "INVALID_STATE": {
       "recovery": "correctable",
       "suggestion": "check current status via get_media_buys and adjust request"
@@ -664,11 +674,19 @@
     },
     "VAST_VERSION_MISMATCH": {
       "recovery": "correctable",
-      "suggestion": "re-tag with a version from error.details.supported_versions, or correct the asset's declared vast_version to match the document"
+      "suggestion": "inspect error.details.mismatch_reason and the corresponding acceptance-set or observed-document fields; select a compatible source representation or correct the offending VAST document"
     },
     "VAST_WRAPPER_DEPTH_EXCEEDED": {
       "recovery": "correctable",
       "suggestion": "inspect error.details.reason (depth, loop, timeout); flatten the wrapper chain, reduce redirects below the format's max_wrapper_depth, or fix the failing hop"
+    },
+    "CREATIVE_REPRESENTATION_UNRESOLVED": {
+      "recovery": "correctable",
+      "suggestion": "inspect every error.details.representation_rejections entry, then choose a compatible format option or supply a compatible representation"
+    },
+    "MACRO_RESOLUTION_FAILED": {
+      "recovery": "correctable",
+      "suggestion": "inspect error.details.macro_resolution_results and route to a resolver that supports the declared dialect, semantic, owner, and encoding depth"
     }
   }
 }
diff --git a/static/schemas/source/enums/macro-dialect.json b/static/schemas/source/enums/macro-dialect.json
new file mode 100644
index 0000000000..d5a1da579b
--- /dev/null
+++ b/static/schemas/source/enums/macro-dialect.json
@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/enums/macro-dialect.json",
+  "title": "Macro Dialect Family",
+  "description": "Governed family for a creative macro token. `vendor` is qualified by an authority-controlled namespace and immutable revision on the declaration/capability; AdCP does not enumerate companies as dialects. `unknown` is declaration-only and always byte-preserved.",
+  "type": "string",
+  "enum": ["adcp", "iab_vast", "iab_daast", "vendor", "unknown"],
+  "enumDescriptions": {
+    "adcp": "AdCP universal macro syntax and semantics.",
+    "iab_vast": "IAB VAST macro syntax, qualified by the referenced live-registry revision.",
+    "iab_daast": "IAB DAAST macro syntax, qualified by the referenced specification/registry revision.",
+    "vendor": "A vendor- or platform-owned macro namespace, qualified by its authoritative URI and immutable revision.",
+    "unknown": "The token namespace cannot be established. Preserve the token unchanged and never advertise it as resolvable."
+  }
+}
diff --git a/static/schemas/source/enums/macro-mapping-status.json b/static/schemas/source/enums/macro-mapping-status.json
new file mode 100644
index 0000000000..4a0fb4dc5f
--- /dev/null
+++ b/static/schemas/source/enums/macro-mapping-status.json
@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/enums/macro-mapping-status.json",
+  "title": "Macro Mapping Status",
+  "description": "Evidence level connecting a dialect-local macro meaning to the AdCP universal vocabulary.",
+  "type": "string",
+  "enum": ["verified_universal", "dialect_defined", "unresolved"],
+  "enumDescriptions": {
+    "verified_universal": "The cited dialect mapping verifies an AdCP universal semantic.",
+    "dialect_defined": "The dialect defines the token, but no AdCP universal semantic is asserted.",
+    "unresolved": "No safe meaning is established; the token remains byte-preserved."
+  }
+}
diff --git a/static/schemas/source/enums/macro-processing-operation.json b/static/schemas/source/enums/macro-processing-operation.json
new file mode 100644
index 0000000000..8ffa84388c
--- /dev/null
+++ b/static/schemas/source/enums/macro-processing-operation.json
@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/enums/macro-processing-operation.json",
+  "title": "Macro Processing Operation",
+  "description": "The next authorized operation on the current source token.",
+  "type": "string",
+  "enum": ["translate_to_native", "resolve_value", "preserve"],
+  "enumDescriptions": {
+    "translate_to_native": "Replace the current token with a declared downstream-native token; no concrete runtime value is inserted at this step.",
+    "resolve_value": "Insert the concrete runtime value using the declared encoding contract.",
+    "preserve": "Leave the source bytes unchanged because no safe local operation is established."
+  }
+}
diff --git a/static/schemas/source/enums/macro-resolution-reason.json b/static/schemas/source/enums/macro-resolution-reason.json
new file mode 100644
index 0000000000..36ae0fe59e
--- /dev/null
+++ b/static/schemas/source/enums/macro-resolution-reason.json
@@ -0,0 +1,21 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/enums/macro-resolution-reason.json",
+  "title": "Macro Resolution Reason",
+  "description": "Structured reason for a macro preflight result.",
+  "type": "string",
+  "enum": [
+    "capability_match",
+    "preserved_unknown",
+    "preserved_for_downstream",
+    "dialect_unsupported",
+    "namespace_mismatch",
+    "revision_mismatch",
+    "semantic_unsupported",
+    "operation_unsupported",
+    "resolver_mismatch",
+    "context_unsupported",
+    "encoding_unsupported",
+    "ambiguous_mapping"
+  ]
+}
diff --git a/static/schemas/source/enums/macro-resolver.json b/static/schemas/source/enums/macro-resolver.json
new file mode 100644
index 0000000000..44e9824337
--- /dev/null
+++ b/static/schemas/source/enums/macro-resolver.json
@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/enums/macro-resolver.json",
+  "title": "Macro Processing Actor",
+  "description": "Protocol role authorized to translate the token or bind its concrete value.",
+  "type": "string",
+  "enum": ["buyer", "creative_agent", "seller", "request_executor", "source_ad_server"],
+  "enumDescriptions": {
+    "buyer": "The buyer agent acts before submission.",
+    "creative_agent": "The creative agent executing build_creative, preview_creative, or validate_input performs the declared build-time operation.",
+    "seller": "The AdCP seller or its execution adapter acts during trafficking or serving.",
+    "request_executor": "The component executing the governed request acts, whether a client player, publisher player, SSAI service, or another request executor.",
+    "source_ad_server": "The originating creative/ad server acts on its own native token."
+  }
+}
diff --git a/static/schemas/source/enums/macro-value-context.json b/static/schemas/source/enums/macro-value-context.json
new file mode 100644
index 0000000000..4ee939d5c3
--- /dev/null
+++ b/static/schemas/source/enums/macro-value-context.json
@@ -0,0 +1,8 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/enums/macro-value-context.json",
+  "title": "Macro Value Context",
+  "description": "Syntactic occurrence context supported by the first macro contract. Substitution inside arbitrary JavaScript, JSON, or HTML text is intentionally not inferred; use `opaque` and preserve it unless a later governed context is added.",
+  "type": "string",
+  "enum": ["url_query_value", "url_path_segment", "opaque"]
+}
diff --git a/static/schemas/source/enums/representation-selection-strategy.json b/static/schemas/source/enums/representation-selection-strategy.json
new file mode 100644
index 0000000000..da28d88b33
--- /dev/null
+++ b/static/schemas/source/enums/representation-selection-strategy.json
@@ -0,0 +1,8 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/enums/representation-selection-strategy.json",
+  "title": "Representation Selection Strategy",
+  "description": "Deterministic strategy used after filtering a CreativeRepresentationSet against one seller destination contract. `representation_order` selects the first compatible representation in source array order. `highest_compatible_vast` is valid only when the destination format_kind is video_vast; it selects the compatible VAST representation with the highest exact VAST version, and equal-version ties are resolved by source array order. Using it for another format is INVALID_REQUEST and never falls back silently.",
+  "type": "string",
+  "enum": ["representation_order", "highest_compatible_vast"]
+}
diff --git a/static/schemas/source/enums/url-asset-type.json b/static/schemas/source/enums/url-asset-type.json
index eff2876a2c..914426f118 100644
--- a/static/schemas/source/enums/url-asset-type.json
+++ b/static/schemas/source/enums/url-asset-type.json
@@ -2,10 +2,11 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "/schemas/enums/url-asset-type.json",
   "title": "URL Asset Type",
-  "description": "Types of URL assets for tracking and click-through purposes",
+  "description": "Invocation mechanisms for URL assets. `ad_request` invokes a third-party display ad endpoint at impression time; it is not a tracker or click destination.",
   "type": "string",
   "enum": [
     "clickthrough",
+    "ad_request",
     "tracker_pixel",
     "tracker_script"
   ]
diff --git a/static/schemas/source/enums/vast-media-delivery-method.json b/static/schemas/source/enums/vast-media-delivery-method.json
new file mode 100644
index 0000000000..4ad835097e
--- /dev/null
+++ b/static/schemas/source/enums/vast-media-delivery-method.json
@@ -0,0 +1,8 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/enums/vast-media-delivery-method.json",
+  "title": "VAST Media Delivery Method",
+  "description": "Delivery method declared by the required VAST MediaFile `delivery` attribute.",
+  "type": "string",
+  "enum": ["progressive", "streaming"]
+}
diff --git a/static/schemas/source/error-details/creative-representation-unresolved.json b/static/schemas/source/error-details/creative-representation-unresolved.json
new file mode 100644
index 0000000000..01a3c9f849
--- /dev/null
+++ b/static/schemas/source/error-details/creative-representation-unresolved.json
@@ -0,0 +1,27 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/error-details/creative-representation-unresolved.json",
+  "title": "Creative Representation Unresolved Details",
+  "description": "Required details shape for CREATIVE_REPRESENTATION_UNRESOLVED. Carries one structured incompatibility reason for every candidate retained in the CreativeRepresentationSet.",
+  "x-adcp-validation": {
+    "verifier_constraints": {
+      "exact_candidate_coverage": "representation_rejections MUST contain exactly one entry for every candidate representation_id in the unresolved CreativeRepresentationSet: no missing, duplicate, or unknown representation_id values"
+    },
+    "spec": "docs/creative/representation-sets.mdx#resolution-failure"
+  },
+  "type": "object",
+  "properties": {
+    "representation_rejections": {
+      "type": "array",
+      "minItems": 1,
+      "x-adcp-validation": {
+        "unique_item_properties": ["representation_id"]
+      },
+      "items": {
+        "$ref": "/schemas/core/representation-rejection.json"
+      }
+    }
+  },
+  "required": ["representation_rejections"],
+  "additionalProperties": true
+}
diff --git a/static/schemas/source/error-details/creative-revision-content-mismatch.json b/static/schemas/source/error-details/creative-revision-content-mismatch.json
new file mode 100644
index 0000000000..bb9537ba83
--- /dev/null
+++ b/static/schemas/source/error-details/creative-revision-content-mismatch.json
@@ -0,0 +1,19 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/error-details/creative-revision-content-mismatch.json",
+  "title": "Creative Revision Content Mismatch Details",
+  "description": "Typed details for CREATIVE_REVISION_CONTENT_MISMATCH. Identifies the scoped revision without echoing creative content or seller-side fingerprints.",
+  "type": "object",
+  "properties": {
+    "creative_id": {
+      "type": "string",
+      "minLength": 1,
+      "x-entity": "creative"
+    },
+    "revision_id": {
+      "$ref": "/schemas/core/creative-revision-id.json"
+    }
+  },
+  "required": ["creative_id", "revision_id"],
+  "additionalProperties": false
+}
diff --git a/static/schemas/source/error-details/macro-resolution-failed.json b/static/schemas/source/error-details/macro-resolution-failed.json
new file mode 100644
index 0000000000..533b2a190b
--- /dev/null
+++ b/static/schemas/source/error-details/macro-resolution-failed.json
@@ -0,0 +1,18 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/error-details/macro-resolution-failed.json",
+  "title": "Macro Resolution Failed Details",
+  "description": "Required details shape for MACRO_RESOLUTION_FAILED. Carries one path-addressable compatibility result for every declared macro occurrence considered by the resolver.",
+  "type": "object",
+  "properties": {
+    "macro_resolution_results": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "$ref": "/schemas/core/macro-resolution-result.json"
+      }
+    }
+  },
+  "required": ["macro_resolution_results"],
+  "additionalProperties": true
+}
diff --git a/static/schemas/source/error-details/vast-version-mismatch.json b/static/schemas/source/error-details/vast-version-mismatch.json
new file mode 100644
index 0000000000..991e16523e
--- /dev/null
+++ b/static/schemas/source/error-details/vast-version-mismatch.json
@@ -0,0 +1,88 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "/schemas/error-details/vast-version-mismatch.json",
+  "title": "VAST Version Mismatch Details",
+  "description": "Required compatibility details for VAST_VERSION_MISMATCH. Modern emitters discriminate an asset-versus-acceptance mismatch from an inspected-document mismatch. The legacy supported_versions-only arm remains accepted for older 3.x peers.",
+  "type": "object",
+  "properties": {
+    "mismatch_reason": {
+      "type": "string",
+      "enum": ["asset_outside_acceptance", "document_version_mismatch"],
+      "description": "Machine-readable modern mismatch branch."
+    },
+    "asset_vast_version": {
+      "$ref": "/schemas/enums/vast-version.json"
+    },
+    "observed_document_vast_version": {
+      "anyOf": [
+        { "type": "string", "minLength": 1 },
+        { "type": "null" }
+      ],
+      "description": "Raw version observed on the inspected VAST document whose root is being validated. `null` means the required version attribute was missing. This field is intentionally not limited to the governed supported-version enum so diagnostics can report future or invalid document values."
+    },
+    "document_role": {
+      "type": "string",
+      "enum": ["submitted", "wrapper", "terminal_inline"],
+      "description": "Role of the inspected document. Only the submitted document is required to equal the asset declaration; wrapper and terminal documents are checked against the applicable acceptance sets."
+    },
+    "product_vast_versions": {
+      "type": "array",
+      "items": {
+        "$ref": "/schemas/enums/vast-version.json"
+      },
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "seller_vast_versions": {
+      "type": "array",
+      "items": {
+        "$ref": "/schemas/enums/vast-version.json"
+      },
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "format_option_ref": {
+      "$ref": "/schemas/core/format-option-ref.json",
+      "description": "Selected option reference when the product option is addressable. Omitted for a unique id-less product option."
+    },
+    "supported_versions": {
+      "type": "array",
+      "items": { "$ref": "/schemas/enums/vast-version.json" },
+      "minItems": 1,
+      "uniqueItems": true,
+      "deprecated": true,
+      "description": "Deprecated 3.x compatibility field. For an acceptance mismatch, this is the effective product/seller intersection when known. Modern emitters use the typed sets and mismatch_reason."
+    }
+  },
+  "anyOf": [
+    {
+      "title": "Asset outside accepted version intersection",
+      "properties": { "mismatch_reason": { "const": "asset_outside_acceptance" } },
+      "required": ["mismatch_reason", "asset_vast_version", "product_vast_versions", "seller_vast_versions"]
+    },
+    {
+      "title": "Inspected document version mismatch",
+      "properties": { "mismatch_reason": { "const": "document_version_mismatch" } },
+      "required": ["mismatch_reason", "asset_vast_version", "observed_document_vast_version", "document_role"],
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "document_role": { "enum": ["wrapper", "terminal_inline"] }
+            },
+            "required": ["document_role"]
+          },
+          "then": {
+            "required": ["product_vast_versions", "seller_vast_versions"]
+          }
+        }
+      ]
+    },
+    {
+      "title": "Supported versions compatibility details",
+      "required": ["supported_versions"],
+      "not": { "required": ["mismatch_reason"] }
+    }
+  ],
+  "additionalProperties": true
+}
diff --git a/static/schemas/source/formats/canonical/_base.json b/static/schemas/source/formats/canonical/_base.json
index 36691e8a65..4db4a1bf76 100644
--- a/static/schemas/source/formats/canonical/_base.json
+++ b/static/schemas/source/formats/canonical/_base.json
@@ -62,8 +62,8 @@
           },
           "asset_type": {
             "type": "string",
-            "enum": ["image", "video", "audio", "text", "markdown", "url", "html", "css", "javascript", "vast", "daast", "webhook", "brief", "catalog", "published_post", "zip", "card", "object", "pixel_tracker", "vast_tracker", "daast_tracker"],
-            "description": "Discriminator selecting the asset schema this slot accepts. SDK codegen uses this to type the slot value. `published_post` is an existing-post reference asset, not uploaded media bytes and not a catalog row. `card` is the multi-card carousel element type (see card-asset.json). `pixel_tracker` / `vast_tracker` / `daast_tracker` are the renderer-fired measurement-tracker primitives — see `/schemas/core/assets/pixel-tracker-asset.json` and the VAST / DAAST tracker schemas. `object` is a last-resort fallback for structured non-asset inputs that don't fit any primitive asset_type — prefer specific types whenever possible."
+            "enum": ["image", "video", "audio", "text", "markdown", "url", "html", "css", "javascript", "vast", "daast", "display_tag", "webhook", "brief", "catalog", "published_post", "zip", "card", "object", "pixel_tracker", "vast_tracker", "daast_tracker"],
+            "description": "Discriminator selecting the asset schema this slot accepts. SDK codegen uses this to type the slot value. `display_tag` is the atomic third-party display representation (URL, inline markup, or paired redirect). `published_post` is an existing-post reference asset. `pixel_tracker` / `vast_tracker` / `daast_tracker` are renderer-fired tracker primitives. `object` is a last-resort fallback."
           },
           "required": {
             "type": "boolean",
@@ -88,7 +88,7 @@
           "max_size_kb": {
             "type": "integer",
             "minimum": 1,
-            "description": "Per-slot file size limit in kilobytes. Valid only when `asset_type` is `image`, `video`, `audio`, or `zip`. Mutually exclusive with `max_chars` (which applies to text asset types). Schema enforces via if/then so a producer can't set both on the same slot."
+            "description": "Per-slot file size limit in exact kilobytes, where 1 KB = 1,000 bytes. Valid only when `asset_type` is `image`, `video`, `audio`, or `zip`. Mutually exclusive with `max_chars` (which applies to text asset types). Schema enforces via if/then so a producer can't set both on the same slot."
           },
           "pixel_ratios": {
             "type": "array",
@@ -189,7 +189,7 @@
           {
             "$comment": "Non-size asset types (url, catalog, published_post, html, css, javascript, webhook, daast, vast, card, object, pixel_tracker, vast_tracker, daast_tracker) reject both — there's no defined per-slot size semantics on those.",
             "if": {
-              "properties": { "asset_type": { "enum": ["url", "catalog", "published_post", "html", "css", "javascript", "webhook", "daast", "vast", "card", "object", "pixel_tracker", "vast_tracker", "daast_tracker"] } },
+              "properties": { "asset_type": { "enum": ["url", "catalog", "published_post", "html", "css", "javascript", "webhook", "daast", "vast", "display_tag", "card", "object", "pixel_tracker", "vast_tracker", "daast_tracker"] } },
               "required": ["asset_type"]
             },
             "then": {
@@ -220,6 +220,10 @@
       "description": "Typical production turnaround in business days when the format requires seller-side production (e.g., host-recording from a buyer-supplied script). 0 for synchronous (e.g., generative AI); >0 for human-produced (e.g., podcast host-read). Absent when no production is required (buyer uploads complete creative)."
     }
   },
+  "not": {
+    "required": ["macro_resolution_capabilities"]
+  },
   "additionalProperties": true,
-  "x-canonical-policy-required-params-not-enforced": "Canonical format schemas intentionally do NOT mark any of their parameter fields as `required` and use `additionalProperties: true`. The canonical is the loose contract — describing what parameters MAY narrow it. Products narrow the canonical with concrete values (and may also leave most parameters absent — buyers infer behavior from the canonical's prose description for any unspecified parameter). This is intentional, not an oversight: enforcing required params on the canonical would force every product to declare every parameter, which is the wrong direction (we want products to declare only the values that differ from sensible canonical defaults). Adopters writing strict validators should validate against the canonical's structural shape (what fields ARE valid) and apply business rules separately for product-level narrowing minima."
+  "x-canonical-policy-required-params-not-enforced": "Canonical format schemas intentionally do NOT mark parameter fields as required and use additionalProperties: true. The canonical describes which parameters MAY narrow a declaration; it does not supply hidden technical defaults. When a technical parameter is omitted, its meaning comes only from the enclosing declaration's technical_requirements_complete assertion: true means no constraint at that layer, while false or absence means undeclared. Consumers MUST NOT infer an omitted technical constraint from canonical prose, examples, common practice, or implementation defaults. This is intentional: structural schema validation and product-level technical-contract completeness are separate checks.",
+  "x-adcp-file-size-units": "Creative file-size fields ending in `_kb` use exactly 1,000 bytes per KB. Fields ending in `_mb` use exactly 1,000,000 bytes per MB. Fields ending in `_bytes` are exact byte counts."
 }
diff --git a/static/schemas/source/formats/canonical/display_tag.json b/static/schemas/source/formats/canonical/display_tag.json
index 772cd08476..3537cd39c5 100644
--- a/static/schemas/source/formats/canonical/display_tag.json
+++ b/static/schemas/source/formats/canonical/display_tag.json
@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "/schemas/formats/canonical/display_tag.json",
   "title": "Canonical Format: Display Tag",
-  "description": "Third-party-served display tag (JS, iframe, or 1×1 redirect). The buyer's adserver hosts the creative; the seller calls the tag URL at impression time. Slot: `tag_url` (url asset with appropriate `url_type`). Tracking model: opaque to seller — third party serves and measures. Click tracking via redirect URL substitution using universal_macros. Distinct from `image` (static asset hosted by seller) and `html5` (zip bundle hosted by seller).",
+  "description": "Third-party-served display creative delivered as one of three explicit representations: a single ad-request URL, byte-preserved inline markup, or an atomic paired redirect (`ad_request_url` plus `clickthrough_url`). The backward-compatible default slot remains `tag_url` (`url_type: ad_request`). Format options accepting inline or paired delivery override `slots` with a `display_tag` asset and declare `supported_delivery_types`. Tracking is opaque to the seller except for declared macro resolution. Distinct from `image` and seller-hosted `html5` zip bundles.",
   "allOf": [
     {
       "$ref": "/schemas/formats/canonical/_base.json"
@@ -190,7 +190,7 @@
           "required": false
         }
       ],
-      "description": "Default slots for display_tag canonical. Buyer ships a URL pointing at the third-party-served creative (JS, iframe, or 1×1 redirect) plus an optional backup image. Click and impression macros are substituted into the tag URL by the seller using `universal_macros`."
+      "description": "Backward-compatible URL-delivery slots. `tag_url` MUST use `url_type: ad_request`. A format option accepting `inline_markup` or `paired_redirect` overrides this list with a required slot whose `asset_type` is `display_tag`; the display-tag asset keeps paired redirect URLs atomic."
     },
     "width": {
       "type": "integer",
@@ -247,6 +247,7 @@
     },
     "supported_tag_types": {
       "type": "array",
+      "deprecated": true,
       "items": {
         "type": "string",
         "enum": [
@@ -255,7 +256,17 @@
           "1x1_redirect"
         ]
       },
-      "description": "Tag delivery mechanisms accepted."
+      "description": "Deprecated ambiguous mechanism list. Use `supported_delivery_types`; markup subtype lives on the `display_tag` asset."
+    },
+    "supported_delivery_types": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "enum": ["tag_url", "inline_markup", "paired_redirect"]
+      },
+      "description": "Closed set of delivery types this format option can traffic. `paired_redirect` means one atomic ad-request/click-through pair (Internal Redirect semantics), never independently matchable URL slots."
     },
     "ssl_required": {
       "type": "boolean",
diff --git a/static/schemas/source/formats/canonical/video_hosted.json b/static/schemas/source/formats/canonical/video_hosted.json
index e725a5e722..fa254ff5b7 100644
--- a/static/schemas/source/formats/canonical/video_hosted.json
+++ b/static/schemas/source/formats/canonical/video_hosted.json
@@ -69,7 +69,7 @@
     },
     "min_bitrate_kbps": { "type": "integer", "minimum": 1 },
     "max_bitrate_kbps": { "type": "integer", "minimum": 1 },
-    "max_file_size_mb": { "type": "integer", "minimum": 1 },
+    "max_file_size_mb": { "type": "integer", "minimum": 1, "description": "Maximum file size, where 1 MB is exactly 1,000,000 bytes." },
     "frame_rates": {
       "type": "array",
       "items": { "type": "number" }
diff --git a/static/schemas/source/formats/canonical/video_vast.json b/static/schemas/source/formats/canonical/video_vast.json
index 10c15303d8..5c1cec9070 100644
--- a/static/schemas/source/formats/canonical/video_vast.json
+++ b/static/schemas/source/formats/canonical/video_vast.json
@@ -19,9 +19,21 @@
       "type": "string",
       "pattern": "^[0-9]+(\\.[0-9]+)?:[0-9]+(\\.[0-9]+)?$"
     },
+    "vast_versions": {
+      "type": "array",
+      "items": { "$ref": "/schemas/enums/vast-version.json" },
+      "minItems": 1,
+      "uniqueItems": true,
+      "description": "VAST versions accepted by this product format option. The asset still declares exactly one `vast_version`; compatibility requires membership in this set and the seller-wide execution set."
+    },
     "vast_version": {
       "$ref": "/schemas/enums/vast-version.json",
-      "description": "Required VAST version."
+      "deprecated": true,
+      "description": "Deprecated one-element alias for `vast_versions`. Producers use either the singular legacy alias or the plural 3.2 field, never both."
+    },
+    "media_file_requirements": {
+      "$ref": "/schemas/core/vast-media-file-requirements.json",
+      "description": "Technical acceptance constraints for alternative VAST MediaFile renditions. Each applicable resolved InLine linear creative needs at least one MediaFile satisfying all declared constraints."
     },
     "vpaid_enabled": {
       "type": "boolean",
@@ -47,10 +59,10 @@
       "minimum": 1,
       "description": "When set, duration must equal exactly this value. Takes precedence over `duration_ms_range` when both ship."
     },
-    "min_width": { "type": "integer", "minimum": 1 },
-    "max_width": { "type": "integer", "minimum": 1 },
-    "min_height": { "type": "integer", "minimum": 1 },
-    "max_height": { "type": "integer", "minimum": 1 },
+    "min_width": { "type": "integer", "minimum": 1, "description": "Minimum placement/player width in pixels. MediaFile rendition dimensions are declared in `media_file_requirements`." },
+    "max_width": { "type": "integer", "minimum": 1, "description": "Maximum placement/player width in pixels. MediaFile rendition dimensions are declared in `media_file_requirements`." },
+    "min_height": { "type": "integer", "minimum": 1, "description": "Minimum placement/player height in pixels. MediaFile rendition dimensions are declared in `media_file_requirements`." },
+    "max_height": { "type": "integer", "minimum": 1, "description": "Maximum placement/player height in pixels. MediaFile rendition dimensions are declared in `media_file_requirements`." },
     "creative_type": {
       "type": "string",
       "enum": ["linear", "nonlinear", "either"],
@@ -124,5 +136,6 @@
     },
     "spec": "docs/creative/ctv-experiences.mdx"
   },
-  "additionalProperties": true
+  "additionalProperties": true,
+  "not": { "required": ["vast_version", "vast_versions"] }
 }
diff --git a/static/schemas/source/index.json b/static/schemas/source/index.json
index 7c24c5e02d..e978317050 100644
--- a/static/schemas/source/index.json
+++ b/static/schemas/source/index.json
@@ -386,6 +386,50 @@
           "$ref": "/schemas/core/creative-manifest.json",
           "description": "Complete specification of a creative with all assets needed for rendering"
         },
+        "creative-representation-set": {
+          "$ref": "/schemas/core/creative-representation-set.json",
+          "description": "Complete immutable creative revision containing equivalent pre-binding trafficking representations"
+        },
+        "creative-representation": {
+          "$ref": "/schemas/core/creative-representation.json",
+          "description": "One canonical pre-binding trafficking representation within a representation set"
+        },
+        "representation-destination": {
+          "$ref": "/schemas/core/representation-destination.json",
+          "description": "Seller-owned product and format context for deterministic representation resolution"
+        },
+        "representation-selection": {
+          "$ref": "/schemas/core/representation-selection.json",
+          "description": "Source-revision, selected-representation, strategy, and derived-output lineage"
+        },
+        "representation-rejection": {
+          "$ref": "/schemas/core/representation-rejection.json",
+          "description": "Structured incompatibility reason for one rejected representation"
+        },
+        "macro-bearing-url": {
+          "$ref": "/schemas/core/macro-bearing-url.json",
+          "description": "HTTP(S) URL or legacy URI template that may contain declared or opaque macro tokens"
+        },
+        "macro-declaration": {
+          "$ref": "/schemas/core/macro-declaration.json",
+          "description": "Occurrence-level source token, semantic, actor, context, and encoding contract"
+        },
+        "macro-encoding": {
+          "$ref": "/schemas/core/macro-encoding.json",
+          "description": "Exact macro value encoding kind and pass depth"
+        },
+        "macro-resolution-capability": {
+          "$ref": "/schemas/core/macro-resolution-capability.json",
+          "description": "Exact dialect-semantic macro processing capability tuple"
+        },
+        "macro-resolution-result": {
+          "$ref": "/schemas/core/macro-resolution-result.json",
+          "description": "Path-addressable macro compatibility result for one declaration"
+        },
+        "macro-translation-target": {
+          "$ref": "/schemas/core/macro-translation-target.json",
+          "description": "Native token contract emitted by a macro translation operation"
+        },
         "performance-feedback": {
           "$ref": "/schemas/core/performance-feedback.json",
           "description": "Stored processing record for performance feedback"
@@ -398,6 +442,10 @@
           "$ref": "/schemas/core/creative-variant.json",
           "description": "A specific execution variant of a creative with performance metrics"
         },
+        "creative-revision-id": {
+          "$ref": "/schemas/core/creative-revision-id.json",
+          "description": "Buyer-assigned immutable input-content revision identity scoped to a creative"
+        },
         "property": {
           "$ref": "/schemas/core/property.json",
           "description": "An advertising property that can be validated via adagents.json"
@@ -1145,6 +1193,10 @@
           "$ref": "/schemas/enums/vast-version.json",
           "description": "Supported VAST specification versions (2.0, 3.0, 4.0, 4.1, 4.2, 4.3)"
         },
+        "representation-selection-strategy": {
+          "$ref": "/schemas/enums/representation-selection-strategy.json",
+          "description": "Deterministic strategy for selecting one compatible creative representation"
+        },
         "vast-tracking-event": {
           "$ref": "/schemas/enums/vast-tracking-event.json",
           "description": "Standard VAST tracking events for video playback and interaction"
diff --git a/static/schemas/source/media-buy/build-creative-request.json b/static/schemas/source/media-buy/build-creative-request.json
index 41eaa593bc..b39303996e 100644
--- a/static/schemas/source/media-buy/build-creative-request.json
+++ b/static/schemas/source/media-buy/build-creative-request.json
@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "/schemas/media-buy/build-creative-request.json",
   "title": "Build Creative Request",
-  "description": "Request to transform, generate, refine, or retrieve a creative manifest. Supports four modes: (1) generation from a brief or seed assets, (2) transformation of an existing manifest, (3) refinement of a prior produced variant via refine_from_build_variant_id (re-build with a natural-language message + config delta), (4) retrieval from a creative library by creative_id. Produces target manifest(s) through canonical capabilities advertised in `get_adcp_capabilities.creative.supported_formats[]`. In 3.2, provide `target_capability_id` for one output or `target_capability_ids` for multiple outputs. Legacy `target_format_id` / `target_format_ids` remain accepted during the 3.x compatibility window but are deprecated.",
+  "description": "Request to transform, generate, resolve, refine, or retrieve a creative manifest. Supports five modes: (1) generation from a brief or seed assets, (2) transformation of an existing manifest, (3) deterministic seller-bound selection from a pre-binding CreativeRepresentationSet, (4) refinement of a prior produced variant via refine_from_build_variant_id, and (5) retrieval from a creative library by creative_id. Produces target manifest(s) through canonical capabilities advertised in `get_adcp_capabilities.creative.supported_formats[]`. CreativeRepresentationSet input is a non-generative, single-output mode available only on the destination sales agent and additionally requires `creative.representation_resolution.supported: true`. In 3.2, provide `target_capability_id` for one output or `target_capability_ids` for multiple outputs. Legacy named-format selectors remain accepted during the 3.x compatibility window but are deprecated.",
   "x-tool-summary": "Generate, transform, refine, retrieve, or adapt creative manifests for advertised creative capabilities.",
   "type": "object",
   "allOf": [
@@ -71,6 +71,84 @@
     {
       "$comment": "Refinement targets one prior creative, not a catalog fan-out.",
       "not": { "required": ["refine_from_build_variant_id", "max_creatives"] }
+    },
+    {
+      "$comment": "A CreativeRepresentationSet is one complete revision input and cannot be mixed with a manifest, library creative, or refinement handle.",
+      "not": {
+        "anyOf": [
+          { "required": ["creative_representation_set", "creative_manifest"] },
+          { "required": ["creative_representation_set", "creative_id"] },
+          { "required": ["creative_representation_set", "refine_from_build_variant_id"] }
+        ]
+      }
+    },
+    {
+      "$comment": "Representation-set resolution is a seller-bound, deterministic, single-output selection mode. It cannot generate, transform, refine, evaluate, sample, or fan out content.",
+      "if": { "required": ["creative_representation_set"] },
+      "then": {
+        "required": ["representation_destination", "representation_selection_strategy", "target_capability_id"],
+        "properties": {
+          "mode": { "const": "execute" }
+        },
+        "not": {
+          "anyOf": [
+            { "required": ["message"] },
+            { "required": ["creative_manifest"] },
+            { "required": ["creative_id"] },
+            { "required": ["transformer_id"] },
+            { "required": ["config"] },
+            { "required": ["refine_from_build_variant_id"] },
+            { "required": ["max_creatives"] },
+            { "required": ["signal_conditions"] },
+            { "required": ["max_variants"] },
+            { "required": ["variant_axis"] },
+            { "required": ["selection_strategy"] },
+            { "required": ["item_limit"] },
+            { "required": ["evaluator"] },
+            { "required": ["quality"] },
+            { "required": ["concept_id"] },
+            { "required": ["keep_mode"] },
+            { "required": ["max_spend"] },
+            { "required": ["brand"] },
+            { "required": ["media_buy_id"] },
+            { "required": ["package_id"] },
+            { "required": ["target_capability_ids"] },
+            { "required": ["target_format_id"] },
+            { "required": ["target_format_ids"] }
+          ]
+        }
+      }
+    },
+    {
+      "$comment": "Destination and representation strategy have no meaning outside representation-set resolution.",
+      "if": {
+        "anyOf": [
+          { "required": ["representation_destination"] },
+          { "required": ["representation_selection_strategy"] }
+        ]
+      },
+      "then": { "required": ["creative_representation_set"] }
+    },
+    {
+      "$comment": "highest_compatible_vast is defined only for VAST destinations; callers use representation_order for other format kinds.",
+      "if": {
+        "properties": { "representation_selection_strategy": { "const": "highest_compatible_vast" } },
+        "required": ["representation_selection_strategy"]
+      },
+      "then": {
+        "properties": {
+          "representation_destination": {
+            "properties": {
+              "format_option": {
+                "properties": { "format_kind": { "const": "video_vast" } },
+                "required": ["format_kind"]
+              }
+            },
+            "required": ["format_option"]
+          }
+        },
+        "required": ["representation_destination"]
+      }
     }
   ],
   "x-mutates-state": true,
@@ -96,6 +174,18 @@
       "$ref": "/schemas/core/creative-manifest.json",
       "description": "Creative manifest to transform or generate from. On the canonical 3.2 path it carries `format_kind`, optional `format_option_ref`, and the required input assets. For transformation (for example resizing or reformatting), this is the complete creative to adapt. When creative_id is provided, the agent resolves the creative from its library and this field is ignored."
     },
+    "creative_representation_set": {
+      "$ref": "/schemas/core/creative-representation-set.json",
+      "description": "Complete creative revision containing equivalent trafficking representations, of which exactly one is selected for this seller-bound output. This mode is accepted only by the destination sales agent and requires representation_destination plus representation_selection_strategy. The target capability selects the seller's build route; representation_destination supplies the binding inventory contract. The resolver verifies revision_content_digest against the complete set, retains every representation unchanged, selects exactly one compatible representation, and returns a manifest carrying representation_selection. If macro_values is present, selection happens first and binding affects only the derived output; the retained representation set and its revision binding never change. When none is compatible, the request fails with CREATIVE_REPRESENTATION_UNRESOLVED and one representation_rejections entry per candidate."
+    },
+    "representation_destination": {
+      "$ref": "/schemas/core/representation-destination.json",
+      "description": "Seller-owned product and effective format context for representation resolution. Required only with creative_representation_set and meaningful only when this endpoint is the destination sales agent."
+    },
+    "representation_selection_strategy": {
+      "$ref": "/schemas/enums/representation-selection-strategy.json",
+      "description": "Deterministic strategy to apply after compatibility filtering. Required with creative_representation_set and MUST be advertised by creative.representation_resolution.strategies."
+    },
     "creative_id": {
       "type": "string",
       "description": "Reference to a creative in the agent's library. The creative agent resolves this to a manifest from its library. Use this instead of creative_manifest when retrieving an existing creative for tag generation or format adaptation.",
@@ -313,7 +403,7 @@
     },
     "macro_values": {
       "type": "object",
-      "description": "Macro values to pre-substitute into the output manifest's assets. Keys are universal macro names (e.g., CLICK_URL, CACHEBUSTER); values are the substitution strings. The creative agent translates universal macros to its platform's native syntax. Substitution is literal — all occurrences of each macro in output assets are replaced with the provided value. The caller is responsible for URL-encoding values if the output context requires it. Macros not provided here remain as {MACRO} placeholders for the sales agent to resolve at serve time. Creative agents MUST ignore keys they do not recognize — unknown macro names are not an error.",
+      "description": "Raw concrete values offered for build-time binding, keyed by AdCP universal semantic (for example CLICK_URL or CACHEBUSTER). With declarations, a value binds only a verified-universal `resolve_value` occurrence performed_by `creative_agent`, using that declaration's exact context and encoding; callers MUST NOT pre-encode it. The selected `creative.supported_formats[]` route's macro_resolution_capabilities is the binding build/preview capability set; seller-wide and product sets apply only on the sales execution path. Values never short-circuit `translate_to_native`: translation emits its target declaration and the complete target capability chain remains required. For creative_representation_set, selection happens before binding and the complete representation set remains byte-identical. Without declarations, the 3.x legacy path remains: creative agents may translate recognized AdCP tokens using the existing `translateUniversalMacros` contract, preserve omitted placeholders for the sales agent, and ignore unknown keys. Existing unmapped/frozen-consent diagnostics remain required.",
       "additionalProperties": {
         "type": "string"
       }
diff --git a/static/schemas/source/media-buy/build-creative-response.json b/static/schemas/source/media-buy/build-creative-response.json
index b36bed67ed..fc047d0e5b 100644
--- a/static/schemas/source/media-buy/build-creative-response.json
+++ b/static/schemas/source/media-buy/build-creative-response.json
@@ -3,6 +3,21 @@
   "$id": "/schemas/media-buy/build-creative-response.json",
   "title": "Build Creative Response",
   "description": "Response payload for build_creative. Exactly one of six shapes: (1) synchronous single-capability success — creative_manifest issued in-line; (2) synchronous multi-capability success — creative_manifests issued in request order; (3) multiplicity success — creatives[] each carrying variants[]; (4) dry-run estimate; (5) terminal failure; (6) submitted task envelope. Canonical 3.2 requests use target_capability_id(s); deprecated target_format_id(s) retain the same response branches during the 3.x compatibility window.",
+  "x-adcp-validation": {
+    "verifier_constraints": {
+      "representation_resolution_response": {
+        "when": "the corresponding request carries creative_representation_set",
+        "success_shape": "MUST use the single creative_manifest success branch",
+        "lineage_required": "creative_manifest.representation_selection MUST be present",
+        "source_match": "creative_id, revision_id, revision_content_digest, and selected_representation_id MUST match the verified source set and selected member",
+        "strategy_match": "representation_selection.strategy MUST equal request.representation_selection_strategy",
+        "output_digest": "representation_selection.selected_output_digest MUST verify with the shared manifest projection after removing exactly top-level $schema, representation_selection, creative_id, revision_id, name, tags, status, weight, placement_refs, placement_ids, and inputs",
+        "resolver_actor": "representation_selection.resolved_by MUST equal seller for this seller-bound build_creative mode",
+        "build_variant_id": "MUST be absent because deterministic representation selection does not create a build variant"
+      }
+    },
+    "spec": "docs/creative/representation-sets.mdx#seller-bound-resolution"
+  },
   "type": "object",
   "allOf": [
     {
@@ -20,7 +35,7 @@
       "properties": {
         "creative_manifest": {
           "$ref": "/schemas/core/creative-manifest.json",
-          "description": "The generated or transformed creative manifest"
+          "description": "The generated, transformed, retrieved, or deterministically selected creative manifest. For creative_representation_set input it MUST carry exact representation_selection lineage."
         },
         "build_variant_id": {
           "type": "string",
diff --git a/static/schemas/source/protocol/get-adcp-capabilities-response.json b/static/schemas/source/protocol/get-adcp-capabilities-response.json
index 6ff4dcf222..8c627c22b6 100644
--- a/static/schemas/source/protocol/get-adcp-capabilities-response.json
+++ b/static/schemas/source/protocol/get-adcp-capabilities-response.json
@@ -1078,10 +1078,20 @@
               "properties": {
                 "vast_versions": {
                   "type": "array",
-                  "description": "VAST versions supported for video creatives",
-                  "items": {
-                    "type": "string",
-                    "pattern": "^[0-9]+\\.[0-9]+$"
+                  "description": "Seller-wide VAST execution ceiling. Each product format option declares its binding accepted subset in `params.vast_versions`.",
+                  "items": { "$ref": "/schemas/enums/vast-version.json" },
+                  "minItems": 1,
+                  "uniqueItems": true
+                },
+                "macro_resolution_capabilities": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": { "$ref": "/schemas/core/macro-resolution-capability.json" },
+                  "description": "Seller-wide ceiling for exact macro processing tuples (dialect identity/revision, semantic mapping, operation, actor, context, and encoding). It never proves a product execution path supports the same tuple and does not claim tracker firing; inspect the selected format option and, when standardized, product tracker capabilities.",
+                  "x-adcp-validation": {
+                    "verifier_constraints": {
+                      "translation_chain_closure": "every translate_to_native entry must have an exact matching resolve_value entry for its translation_target in this same array"
+                    }
                   }
                 },
                 "mraid_versions": {
@@ -1989,6 +1999,11 @@
           "description": "When true, this agent hosts a creative library and supports list_creatives and creative_id references in build_creative. Creative agents with a library should also implement the accounts protocol (sync_accounts / list_accounts) so buyers can establish access.",
           "default": false
         },
+        "supports_revisions": {
+          "type": "boolean",
+          "description": "When true, this agent accepts buyer-assigned revision_id on sync_creatives, enforces immutable revision content, echoes accepted revision identity, returns it from list_creatives, and attributes delivered executions to it. Revision support does not imply revision history, rollback, or staged activation.",
+          "default": false
+        },
         "supports_generation": {
           "type": "boolean",
           "description": "When true, this agent can generate creatives from natural language briefs via build_creative. The buyer provides a message with creative direction, and the agent produces a manifest with generated assets. When false, build_creative only supports transformation or library retrieval.",
@@ -1999,6 +2014,33 @@
           "description": "When true, this agent can transform or resize existing canonical manifests via build_creative. The buyer supplies a creative_manifest and an advertised target_capability_id.",
           "default": false
         },
+        "representation_resolution": {
+          "type": "object",
+          "description": "Explicit opt-in for deterministic seller-bound selection from `build_creative.creative_representation_set`. Only the destination sales agent may advertise and exercise this capability because resolution requires its current product, placement/publisher narrowings, and seller-wide execution ceilings. A standalone creative agent may help a buyer select locally but MUST NOT advertise this capability or claim seller deliverability. Absence means the caller selects a representation before sending a seller-bound manifest; the agent MUST NOT guess silently.",
+          "properties": {
+            "supported": {
+              "type": "boolean",
+              "const": true,
+              "description": "True means the agent accepts CreativeRepresentationSet input and returns `representation_selection` or per-candidate structured rejections."
+            },
+            "strategies": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": { "$ref": "/schemas/enums/representation-selection-strategy.json" },
+              "description": "Deterministic selection strategies the seller implements after compatibility filtering. `representation_order` selects the first compatible source entry. `highest_compatible_vast` selects the highest exact VAST version from the already-intersected candidate set, with equal-version ties resolved by source array order."
+            }
+          },
+          "required": ["supported", "strategies"],
+          "additionalProperties": true,
+          "x-adcp-validation": {
+            "verifier_constraints": {
+              "advertiser_role": "only a destination sales agent with media_buy product authority may advertise this capability",
+              "request_strategy": "representation_selection_strategy MUST be one of the advertised strategies",
+              "destination_authority": "the seller MUST resolve representation_destination against its own current product and execution capabilities"
+            }
+          }
+        },
         "supports_transformers": {
           "type": "boolean",
           "description": "When true, this agent exposes account-scoped creative transformers via list_transformers (the creative analog of media-buy products) and accepts transformer_id + config on build_creative. Buyers SHOULD call list_transformers to discover available transformers, their typed config params (and account-scoped enumerable option values via expand_params), and pricing. When false or absent, the agent does not offer the transformer surface.",
@@ -2208,6 +2250,20 @@
             "required": ["has_creative_library"]
           }
         },
+        {
+          "if": {
+            "properties": {
+              "supports_revisions": { "const": true }
+            },
+            "required": ["supports_revisions"]
+          },
+          "then": {
+            "properties": {
+              "has_creative_library": { "type": "boolean", "const": true }
+            },
+            "required": ["has_creative_library"]
+          }
+        },
         {
           "if": {
             "properties": {
diff --git a/tests/composed-schema-validation.test.cjs b/tests/composed-schema-validation.test.cjs
index 49d3d36687..62d1978ad8 100644
--- a/tests/composed-schema-validation.test.cjs
+++ b/tests/composed-schema-validation.test.cjs
@@ -6976,18 +6976,19 @@ async function runTests() {
   await testSchemaValidation(
     '/schemas/core/creative-variant.json',
     { variant_id: 'served_4821', locale_variant_id: 'loc_es_es' },
-    'Delivery variants can attribute the localized assets that served'
+    'Served variants can attribute the localized assets that served'
   );
   testValidationAnnotation(
     '/schemas/core/creative-variant.json',
     {
       localized_parent: {
         required_field: 'locale_variant_id',
-        member_of: 'list_creatives.localization.variants[].locale_variant_id',
+        member_of: 'accepted_source_revision.localization.variants[].locale_variant_id',
+        current_list_localization_not_required: true,
         applies_to_default_fallback: true
       }
     },
-    'Delivery variants expose machine-readable localized attribution rules'
+    'Served variants expose machine-readable historical localization attribution rules'
   );
 
   const localizedCanonicalListItem = structuredClone(localizedListItem);
diff --git a/tests/creative-delivery-contracts.test.cjs b/tests/creative-delivery-contracts.test.cjs
new file mode 100644
index 0000000000..1797567974
--- /dev/null
+++ b/tests/creative-delivery-contracts.test.cjs
@@ -0,0 +1,1109 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const crypto = require('node:crypto');
+const path = require('node:path');
+const test = require('node:test');
+const { isDeepStrictEqual } = require('node:util');
+const Ajv = require('ajv').default;
+const addFormats = require('ajv-formats').default;
+
+const ROOT = path.resolve(__dirname, '..');
+const SCHEMAS = path.join(ROOT, 'static/schemas/source');
+const VECTORS = path.join(ROOT, 'static/compliance/source/test-vectors/creative-representation-resolution.json');
+const VECTOR_SCHEMA = path.join(ROOT, 'static/compliance/source/test-vectors/creative-representation-resolution.schema.json');
+const MACRO_VECTORS = path.join(ROOT, 'static/compliance/source/test-vectors/macro-processing.json');
+const MACRO_VECTOR_SCHEMA = path.join(ROOT, 'static/compliance/source/test-vectors/macro-processing.schema.json');
+
+function loadAllSchemas(ajv) {
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.name.endsWith('.json')) {
+        const schema = JSON.parse(fs.readFileSync(full, 'utf8'));
+        if (schema.$id && !ajv.getSchema(schema.$id)) ajv.addSchema(schema, schema.$id);
+      }
+    }
+  }
+  walk(SCHEMAS);
+}
+
+function makeAjv() {
+  const ajv = new Ajv({ allErrors: true, strict: false, discriminator: true });
+  addFormats(ajv);
+  ajv.addFormat('uri-template', true);
+  loadAllSchemas(ajv);
+  return ajv;
+}
+
+const ajv = makeAjv();
+
+test('display tag delivery types are discriminated and paired redirects are atomic', () => {
+  const validate = ajv.getSchema('/schemas/core/assets/display-tag-asset.json');
+  assert.ok(validate);
+
+  assert.equal(validate({
+    asset_type: 'display_tag',
+    delivery_type: 'tag_url',
+    url: 'https://ads.acme-example.com/render?cb={CACHEBUSTER}'
+  }), true);
+  assert.equal(validate({
+    asset_type: 'display_tag',
+    delivery_type: 'inline_markup',
+    markup_type: 'iframe_javascript',
+    markup: '<iframe src="https://ads.acme-example.com/render"></iframe>'
+  }), true);
+  assert.equal(validate({
+    asset_type: 'display_tag',
+    delivery_type: 'paired_redirect',
+    ad_request_url: 'https://ads.acme-example.com/ad',
+    clickthrough_url: 'https://click.acme-example.com/redirect'
+  }), true);
+
+  assert.equal(validate({
+    asset_type: 'display_tag',
+    delivery_type: 'paired_redirect',
+    ad_request_url: 'https://ads.acme-example.com/ad'
+  }), false, 'half-present paired redirects must fail');
+  assert.equal(validate({
+    asset_type: 'html',
+    delivery_type: 'inline_markup',
+    markup_type: 'standard',
+    markup: '<a>not an HTML5 bundle</a>'
+  }), false, 'third-party markup cannot be classified as html/html5');
+});
+
+test('VAST assets stay singular while format and seller acceptance are plural enums', () => {
+  const format = ajv.getSchema('/schemas/formats/canonical/video_vast.json');
+  assert.equal(format({ vast_versions: ['3.0', '4.0', '4.3'] }), true);
+  assert.equal(format({ vast_version: '4.0' }), true, 'deprecated one-element alias remains valid');
+  assert.equal(format({ vast_version: '4.0', vast_versions: ['4.0'] }), false,
+    'singular and plural aliases are mutually exclusive so they cannot diverge');
+  assert.equal(format({ vast_version: '4.0', vast_versions: ['3.0'] }), false);
+  assert.equal(format({ vast_versions: ['4.4'] }), false);
+
+  const capabilities = JSON.parse(fs.readFileSync(
+    path.join(SCHEMAS, 'protocol/get-adcp-capabilities-response.json'),
+    'utf8'
+  ));
+  const vastSchema = capabilities.properties.media_buy.properties.execution.properties.creative_specs.properties.vast_versions;
+  assert.equal(vastSchema.items.$ref, '/schemas/enums/vast-version.json');
+  assert.deepEqual(ajv.getSchema('/schemas/enums/vast-version.json').schema.enum.slice(-2), ['4.2', '4.3']);
+
+  const resolution = capabilities.properties.creative.properties.representation_resolution;
+  assert.equal(resolution.properties.supported.const, true);
+  assert.equal(resolution.properties.strategies.items.$ref,
+    '/schemas/enums/representation-selection-strategy.json');
+  assert.deepEqual(ajv.getSchema('/schemas/enums/representation-selection-strategy.json').schema.enum,
+    ['representation_order', 'highest_compatible_vast']);
+  assert.match(resolution.description, /standalone creative agent/i);
+});
+
+test('VAST technical acceptance is explicit, rendition-scoped, and byte-exact', () => {
+  const requirements = {
+    delivery_methods: ['progressive'],
+    mime_types: ['video/mp4'],
+    containers: ['mp4'],
+    codecs: ['avc1.4d401f'],
+    min_width: 1280,
+    max_width: 1920,
+    min_height: 720,
+    max_height: 1080,
+    min_bitrate_kbps: 1500,
+    max_bitrate_kbps: 8000,
+    max_file_size_bytes: 50000000
+  };
+  const validateRequirements = ajv.getSchema('/schemas/core/vast-media-file-requirements.json');
+  assert.equal(validateRequirements(requirements), true, JSON.stringify(validateRequirements.errors));
+  assert.equal(validateRequirements({ ...requirements, vendor_extension: 'future-value' }), true,
+    'technical requirement objects remain extension-carrying under DR-0009');
+  assert.equal(validateRequirements({ ...requirements, mime_types: ['video/mp4; codecs=avc1'] }), false,
+    'MediaFile MIME requirements are media types, not parameterized Content-Type values');
+  assert.equal(validateRequirements({ ...requirements, max_file_size_bytes: 0 }), false,
+    'the byte limit is a positive exact count');
+  assert.equal(validateRequirements({ ...requirements, containers: ['MP4'] }), false,
+    'container identifiers use normalized lower-case tokens');
+  assert.equal(validateRequirements({ ...requirements, delivery_methods: ['download'] }), false,
+    'delivery methods use the governed VAST progressive/streaming vocabulary');
+  assert.match(validateRequirements.schema['x-adcp-validation'].verifier_constraints.range_order,
+    /min_bitrate_kbps MUST be <= max_bitrate_kbps/);
+  assert.match(validateRequirements.schema['x-adcp-validation'].verifier_constraints.adaptive_bitrate_containment,
+    /entire interval/);
+
+  const validateFormat = ajv.getSchema('/schemas/formats/canonical/video_vast.json');
+  assert.equal(validateFormat({ vast_versions: ['4.2'], media_file_requirements: requirements }), true,
+    JSON.stringify(validateFormat.errors));
+  const validateLegacyRequirements = ajv.getSchema('/schemas/core/requirements/vast-asset-requirements.json');
+  assert.equal(validateLegacyRequirements({ vast_versions: ['4.2'], media_file_requirements: requirements }), true,
+    JSON.stringify(validateLegacyRequirements.errors));
+
+  const validateDeclaration = ajv.getSchema('/schemas/core/product-format-declaration.json');
+  const declaration = {
+    format_option_id: 'vast-preroll-complete',
+    technical_requirements_complete: true,
+    format_kind: 'video_vast',
+    params: { vast_versions: ['4.2'], media_file_requirements: requirements }
+  };
+  assert.equal(validateDeclaration(declaration), true, JSON.stringify(validateDeclaration.errors));
+  const validateCompact = ajv.getSchema('/schemas/core/canonical-format-option.json');
+  assert.equal(validateCompact(declaration), true, JSON.stringify(validateCompact.errors));
+  assert.match(validateDeclaration.schema.properties.technical_requirements_complete.description,
+    /MUST NOT later be rejected for an undisclosed technical constraint/);
+  assert.match(ajv.getSchema('/schemas/formats/canonical/_base.json').schema['x-adcp-file-size-units'],
+    /1,000 bytes per KB/);
+
+  const mediaFileSatisfies = mediaFile =>
+    requirements.delivery_methods.includes(mediaFile.delivery_method) &&
+    requirements.mime_types.some(value => value.toLowerCase() === mediaFile.mime_type.toLowerCase()) &&
+    requirements.containers.includes(mediaFile.container) &&
+    requirements.codecs.includes(mediaFile.codec) &&
+    mediaFile.width >= requirements.min_width && mediaFile.width <= requirements.max_width &&
+    mediaFile.height >= requirements.min_height && mediaFile.height <= requirements.max_height &&
+    mediaFile.bitrate_kbps >= requirements.min_bitrate_kbps &&
+    mediaFile.bitrate_kbps <= requirements.max_bitrate_kbps &&
+    mediaFile.file_size_bytes <= requirements.max_file_size_bytes;
+  const alternatives = [
+    {
+      delivery_method: 'progressive', mime_type: 'video/mp4', container: 'mp4', codec: 'avc1.4d401f',
+      width: 640, height: 360, bitrate_kbps: 900, file_size_bytes: 10000000
+    },
+    {
+      delivery_method: 'progressive', mime_type: 'video/mp4', container: 'mp4', codec: 'avc1.4d401f',
+      width: 1920, height: 1080, bitrate_kbps: 6000, file_size_bytes: 49000000
+    }
+  ];
+  assert.equal(alternatives.some(mediaFileSatisfies), true,
+    'one fully compatible rendition is sufficient despite incompatible siblings');
+  assert.equal([
+    { ...alternatives[0], width: 1920, height: 1080 },
+    { ...alternatives[1], codec: 'vp09.00.10.08' }
+  ].some(mediaFileSatisfies), false,
+    'requirements cannot be combined across different MediaFile elements');
+  assert.equal(mediaFileSatisfies({ ...alternatives[1], delivery_method: 'streaming' }), false,
+    'the same rendition must satisfy the declared delivery method');
+  assert.equal(mediaFileSatisfies({ ...alternatives[1], codec: undefined }), false,
+    'missing metadata cannot silently satisfy a declared technical constraint');
+
+  const validateManifest = ajv.getSchema('/schemas/core/creative-manifest.json');
+  const canonicalVastManifest = {
+    format_kind: 'video_vast',
+    assets: {
+      vast_tag: {
+        asset_type: 'vast',
+        delivery_type: 'url',
+        url: 'https://ads.acme-example.com/vast',
+        vast_version: '4.2'
+      }
+    }
+  };
+  assert.equal(validateManifest(canonicalVastManifest), true, JSON.stringify(validateManifest.errors));
+  const customSlotVastManifest = structuredClone(canonicalVastManifest);
+  customSlotVastManifest.assets.vast_xml = customSlotVastManifest.assets.vast_tag;
+  delete customSlotVastManifest.assets.vast_tag;
+  assert.equal(validateManifest(customSlotVastManifest), true,
+    'canonical VAST exact-version validation follows the asset type, not a default slot name');
+  const arraySlotVastManifest = structuredClone(canonicalVastManifest);
+  arraySlotVastManifest.assets.vast_pool = [arraySlotVastManifest.assets.vast_tag];
+  delete arraySlotVastManifest.assets.vast_tag;
+  assert.equal(validateManifest(arraySlotVastManifest), true,
+    'canonical VAST exact-version validation supports multi-asset slots');
+  const missingExactVersion = structuredClone(canonicalVastManifest);
+  delete missingExactVersion.assets.vast_tag.vast_version;
+  assert.equal(validateManifest(missingExactVersion), true,
+    'ordinary canonical VAST manifests retain additive 3.x compatibility when version is omitted');
+  const customSlotWithoutVersion = structuredClone(customSlotVastManifest);
+  delete customSlotWithoutVersion.assets.vast_xml.vast_version;
+  assert.equal(validateManifest(customSlotWithoutVersion), true,
+    'ordinary custom-slot VAST manifests retain additive compatibility');
+  const arraySlotWithoutVersion = structuredClone(arraySlotVastManifest);
+  delete arraySlotWithoutVersion.assets.vast_pool[0].vast_version;
+  assert.equal(validateManifest(arraySlotWithoutVersion), true,
+    'ordinary multi-asset VAST manifests retain additive compatibility');
+  const extensionSlotWithoutVersion = structuredClone(canonicalVastManifest);
+  extensionSlotWithoutVersion.assets['VAST-TAG'] = extensionSlotWithoutVersion.assets.vast_tag;
+  delete extensionSlotWithoutVersion.assets.vast_tag;
+  delete extensionSlotWithoutVersion.assets['VAST-TAG'].vast_version;
+  assert.equal(validateManifest(extensionSlotWithoutVersion), true,
+    'ordinary extension-slot VAST manifests retain additive compatibility');
+  assert.equal(validateManifest({
+    format_id: { agent_url: 'https://creative.acme.test', id: 'legacy-vast' },
+    assets: missingExactVersion.assets
+  }), true, 'the deprecated named-format path retains 3.x compatibility');
+
+  const validateCreativeAsset = ajv.getSchema('/schemas/core/creative-asset.json');
+  const canonicalVastCreative = {
+    creative_id: 'vast-creative-1',
+    name: 'Acme preroll',
+    ...canonicalVastManifest
+  };
+  assert.equal(validateCreativeAsset(canonicalVastCreative), true, JSON.stringify(validateCreativeAsset.errors));
+  const syncCreativeWithoutVersion = structuredClone(canonicalVastCreative);
+  delete syncCreativeWithoutVersion.assets.vast_tag.vast_version;
+  assert.equal(validateCreativeAsset(syncCreativeWithoutVersion), true,
+    'ordinary sync_creatives VAST payloads retain additive 3.x compatibility');
+  assert.equal(validateCreativeAsset({
+    ...canonicalVastCreative,
+    assets: extensionSlotWithoutVersion.assets
+  }), true, 'ordinary extension-slot sync payloads retain additive compatibility');
+});
+
+test('macro declarations enforce resolver ownership and exact URL encoding depth', () => {
+  const validate = ajv.getSchema('/schemas/core/macro-declaration.json');
+  const valid = {
+    declaration_id: 'nested-click',
+    token: '%%ACME_CLICK_ESC2%%',
+    dialect: 'vendor',
+    dialect_namespace: 'https://macros.acme-example.com/registry',
+    dialect_revision: 'mapping-v1',
+    dialect_semantic: 'CLICK_ESC2',
+    mapping_status: 'verified_universal',
+    universal_semantic: 'CLICK_URL',
+    operation: 'resolve_value',
+    performed_by: 'seller',
+    location: { field: 'url', occurrence: 0, context: 'url_query_value' },
+    encoding: { kind: 'rfc3986', depth: 2 },
+    required: true,
+    unavailable_behavior: 'reject'
+  };
+  assert.equal(validate(valid), true);
+  assert.equal(validate({ ...valid, encoding: { kind: 'rfc3986', depth: 0 } }), false);
+  assert.equal(validate({ ...valid, encoding: { kind: 'none', depth: 1 } }), false);
+  assert.equal(validate({ ...valid, performed_by: 'whoever_guesses' }), false);
+  assert.equal(validate({ ...valid, dialect: 'ttd' }), false, 'dialect aliases must not bypass the governed enum');
+  assert.equal(validate({ ...valid, required: true, unavailable_behavior: 'omit_parameter' }), false);
+  assert.equal(validate({ ...valid, mapping_status: 'dialect_defined' }), false, 'universal mappings cannot survive without verified status');
+
+  const adcp = {
+    ...valid,
+    token: '{CACHEBUSTER}',
+    dialect: 'adcp',
+    dialect_semantic: 'CACHEBUSTER',
+    universal_semantic: 'CACHEBUSTER'
+  };
+  delete adcp.dialect_namespace;
+  delete adcp.dialect_revision;
+  assert.equal(validate(adcp), true);
+  assert.equal(validate({ ...adcp, performed_by: 'creative_agent' }), true,
+    'standalone build/preview execution has an actor distinct from seller trafficking');
+  assert.equal(validate({ ...adcp, dialect_semantic: 'PRIVATE' }), false);
+  const semanticIdentityIsValid = declaration => declaration.dialect !== 'adcp' ||
+    declaration.dialect_semantic === declaration.universal_semantic;
+  assert.equal(semanticIdentityIsValid(adcp), true);
+  assert.equal(semanticIdentityIsValid({ ...adcp, dialect_semantic: 'TIMESTAMP' }), false,
+    'the published AdCP semantic-identity verifier rejects unequal universal names');
+  assert.equal(validate.schema['x-adcp-validation'].verifier_constraints.adcp_semantic_identity.includes('must equal'), true);
+  assert.equal(validate({ ...adcp, mapping_status: 'dialect_defined', universal_semantic: undefined }), false);
+  assert.equal(validate({ ...adcp, location: { field: 'url', occurrence: 0, context: 'opaque' } }), false,
+    'opaque locations are preserve-only');
+  assert.equal(validate({ ...adcp, dialect_semantic: 'SKU', universal_semantic: 'SKU', encoding: { kind: 'rfc3986', depth: 2 } }), false,
+    'catalog values have exactly one RFC3986 pass');
+
+  const unknown = {
+    declaration_id: 'unknown-token',
+    token: '%%UNIDENTIFIED%%',
+    dialect: 'unknown',
+    dialect_semantic: 'unresolved',
+    mapping_status: 'unresolved',
+    operation: 'preserve',
+    location: { field: 'url', occurrence: 0, context: 'opaque' },
+    encoding: { kind: 'none', depth: 0 },
+    required: false,
+    unavailable_behavior: 'preserve'
+  };
+  assert.equal(validate(unknown), true);
+  assert.equal(validate({ ...unknown, performed_by: 'seller' }), false);
+  assert.equal(validate({ ...unknown, universal_semantic: 'CACHEBUSTER' }), false);
+
+  const daastResolution = {
+    declaration_id: 'daast-error',
+    token: '[ERRORCODE]',
+    dialect: 'iab_daast',
+    dialect_namespace: 'https://iabtechlab.com/standards/daast',
+    dialect_revision: 'DAAST-1.1',
+    dialect_semantic: 'ERRORCODE',
+    mapping_status: 'dialect_defined',
+    operation: 'resolve_value',
+    performed_by: 'request_executor',
+    location: { field: 'url', occurrence: 0, context: 'url_query_value' },
+    encoding: { kind: 'rfc3986', depth: 1 },
+    required: true,
+    unavailable_behavior: 'reject'
+  };
+  assert.equal(validate(daastResolution), true, JSON.stringify(validate.errors));
+  assert.equal(validate({ ...daastResolution, performed_by: 'seller' }), false,
+    'IAB DAAST values are supplied by the component executing the request');
+
+  const validateUrlAsset = ajv.getSchema('/schemas/core/assets/url-asset.json');
+  const declaredAsset = {
+    asset_type: 'url',
+    url_type: 'tracker_pixel',
+    url: 'https://track.acme-example.com/pixel?x=%%UNIDENTIFIED%%',
+    macro_declarations: [unknown]
+  };
+  assert.equal(validateUrlAsset(declaredAsset), true, JSON.stringify(validateUrlAsset.errors));
+  assert.equal(validateUrlAsset({
+    ...declaredAsset,
+    macro_declarations: [{ ...unknown, location: { ...unknown.location, field: 'markup' } }]
+  }), false, 'asset schemas constrain declaration fields to fields that the asset actually carries');
+
+  const occurrencesAreValid = asset => {
+    const seenIds = new Set();
+    const seenOccurrences = new Set();
+    return asset.macro_declarations.every(declaration => {
+      if (seenIds.has(declaration.declaration_id)) return false;
+      seenIds.add(declaration.declaration_id);
+      const value = asset[declaration.location.field];
+      if (typeof value !== 'string') return false;
+      let offset = 0;
+      let index = -1;
+      for (let occurrence = 0; occurrence <= declaration.location.occurrence; occurrence++) {
+        index = value.indexOf(declaration.token, offset);
+        if (index < 0) return false;
+        offset = index + declaration.token.length;
+      }
+      const occurrenceKey = `${declaration.location.field}:${index}:${declaration.token.length}`;
+      if (seenOccurrences.has(occurrenceKey)) return false;
+      seenOccurrences.add(occurrenceKey);
+      return true;
+    });
+  };
+  assert.equal(occurrencesAreValid(declaredAsset), true);
+  assert.equal(occurrencesAreValid({
+    ...declaredAsset,
+    macro_declarations: [{ ...unknown, location: { ...unknown.location, occurrence: 999 } }]
+  }), false);
+  assert.equal(occurrencesAreValid({ ...declaredAsset, macro_declarations: [unknown, structuredClone(unknown)] }), false);
+
+  const validateCapability = ajv.getSchema('/schemas/core/macro-resolution-capability.json');
+  assert.equal(validateCapability({
+    dialect: 'iab_vast',
+    dialect_namespace: 'https://interactiveadvertisingbureau.github.io/vast/vast4macros/vast4-macros-latest.html',
+    dialect_revision: 'git:e0858cd714474bf17ef61065097456d7643ff838',
+    dialect_semantic: 'PLAYERSTATE',
+    mapping_status: 'dialect_defined',
+    operation: 'resolve_value',
+    performed_by: 'request_executor',
+    supported_contexts: ['url_query_value'],
+    supported_encodings: [{ kind: 'iab_vast_uri', depth: 1 }]
+  }), true);
+  assert.equal(validateCapability({
+    dialect: 'unknown',
+    dialect_semantic: 'unresolved',
+    mapping_status: 'dialect_defined',
+    operation: 'resolve_value',
+    performed_by: 'seller',
+    supported_contexts: ['opaque'],
+    supported_encodings: [{ kind: 'none', depth: 0 }]
+  }), false, 'unknown dialects can be preserved but never advertised as resolvable');
+  assert.equal(validateCapability({
+    dialect: 'adcp',
+    dialect_semantic: 'CACHEBUSTER',
+    mapping_status: 'verified_universal',
+    universal_semantic: 'CACHEBUSTER',
+    operation: 'resolve_value',
+    performed_by: 'seller',
+    supported_contexts: ['opaque'],
+    supported_encodings: [{ kind: 'rfc3986', depth: 1 }]
+  }), false, 'capabilities cannot advertise mutation in opaque contexts');
+  const daastCapability = {
+    dialect: 'iab_daast',
+    dialect_namespace: 'https://iabtechlab.com/standards/daast',
+    dialect_revision: 'DAAST-1.1',
+    dialect_semantic: 'ERRORCODE',
+    mapping_status: 'dialect_defined',
+    operation: 'resolve_value',
+    performed_by: 'request_executor',
+    supported_contexts: ['url_query_value'],
+    supported_encodings: [{ kind: 'rfc3986', depth: 1 }]
+  };
+  assert.equal(validateCapability(daastCapability), true, JSON.stringify(validateCapability.errors));
+  assert.equal(validateCapability({ ...daastCapability, performed_by: 'seller' }), false);
+
+  const validateTarget = ajv.getSchema('/schemas/core/macro-translation-target.json');
+  const { declaration_id, location, required, unavailable_behavior, operation, ...targetFields } = daastResolution;
+  const daastTarget = { ...targetFields, next_operation: 'resolve_value' };
+  assert.equal(validateTarget(daastTarget), true, JSON.stringify(validateTarget.errors));
+  assert.equal(validateTarget({ ...daastTarget, performed_by: 'seller' }), false);
+});
+
+test('all URL-delivered creative assets preserve registered percent-token dialects', () => {
+  const macroUrl = 'https://track.acme-example.com/pixel?cb=%%CACHEBUSTER%%&click=%%ACME_CLICK_ESC2%%';
+  const maskOpaqueTokenForms = value => value.replace(
+    /%%[A-Za-z0-9_.:-]+%%|\$\{[A-Za-z][A-Za-z0-9_]*\}|\{[A-Za-z][A-Za-z0-9_]*\}|\[[A-Za-z][A-Za-z0-9_]*\]/g,
+    'ADCPMACRO'
+  );
+  const structurallyValidHttpUrl = value => {
+    const masked = maskOpaqueTokenForms(value);
+    if (!/^https?:\/\/[^/?#\s]+(?:[/?#]|$)/.test(masked)) return false;
+    if (/%(?![0-9A-Fa-f]{2})/.test(masked)) return false;
+    try {
+      const parsed = new URL(masked);
+      return (parsed.protocol === 'https:' || parsed.protocol === 'http:')
+        && parsed.hostname !== '.';
+    } catch {
+      return false;
+    }
+  };
+  assert.equal(structurallyValidHttpUrl(macroUrl), true,
+    'undeclared legacy token spellings are masked for structure without assigning semantics');
+  assert.match(ajv.getSchema('/schemas/core/macro-bearing-url.json').schema['x-adcp-validation']
+    .verifier_constraints.macro_aware_uri, /undeclared 3\.x compatibility path/);
+  const cases = [
+    ['/schemas/core/assets/url-asset.json', { asset_type: 'url', url: macroUrl, url_type: 'tracker_pixel' }],
+    ['/schemas/core/assets/pixel-tracker-asset.json', { asset_type: 'pixel_tracker', event: 'impression', url: macroUrl }],
+    ['/schemas/core/assets/vast-tracker-asset.json', { asset_type: 'vast_tracker', vast_event: 'start', url: macroUrl }],
+    ['/schemas/core/assets/daast-tracker-asset.json', { asset_type: 'daast_tracker', daast_event: 'start', url: macroUrl }],
+    ['/schemas/core/assets/vast-asset.json', { asset_type: 'vast', delivery_type: 'url', url: macroUrl }],
+    ['/schemas/core/assets/daast-asset.json', { asset_type: 'daast', delivery_type: 'url', url: macroUrl }]
+  ];
+
+  for (const [schemaId, asset] of cases) {
+    const validate = ajv.getSchema(schemaId);
+    assert.equal(validate(asset), true, `${schemaId}: ${JSON.stringify(validate.errors)}`);
+    for (const malformed of ['https:///path', 'https://?x=1', 'https://%zz', 'http://.']) {
+      assert.equal(structurallyValidHttpUrl(malformed), false, `macro-aware verifier: ${malformed}`);
+    }
+  }
+
+  const validateUrl = ajv.getSchema('/schemas/core/assets/url-asset.json');
+  assert.equal(validateUrl({ asset_type: 'url', url: "https://track.acme-example.com/o'clock", url_type: 'clickthrough' }), true,
+    'valid plain HTTP URLs retain ordinary URI behavior');
+  for (const legacyUrl of [
+    'myapp://creative/launch',
+    '//cdn.example.test/creative.js',
+    'https://{PUB}.track.example/pixel'
+  ]) {
+    assert.equal(validateUrl({ asset_type: 'url', url: legacyUrl, url_type: 'clickthrough' }), true,
+      `the published uri-template branch remains backward compatible: ${legacyUrl}`);
+  }
+});
+
+test('creative representation resolution vectors retain the complete revision and select only compatible candidates', async () => {
+  const canonicalize = (await import('canonicalize')).default;
+  const fixture = JSON.parse(fs.readFileSync(VECTORS, 'utf8'));
+  const validateFixture = ajv.compile(JSON.parse(fs.readFileSync(VECTOR_SCHEMA, 'utf8')));
+  const validateSource = ajv.getSchema('/schemas/core/creative-representation-set.json');
+  assert.equal(validateFixture(fixture), true, JSON.stringify(validateFixture.errors));
+
+  for (const vector of fixture.vectors) {
+    assert.equal(validateSource(vector.representation_set), true, `${vector.name}: ${JSON.stringify(validateSource.errors)}`);
+    const digestInput = structuredClone(vector.representation_set);
+    for (const key of ['$schema', 'creative_id', 'revision_id', 'revision_content_digest', 'name']) delete digestInput[key];
+    const actualDigest = `sha256:${crypto.createHash('sha256').update(canonicalize(digestInput)).digest('hex')}`;
+    assert.equal(actualDigest, vector.representation_set.revision_content_digest,
+      `${vector.name}: revision digest binds the complete representation set`);
+    const compatible = [];
+    const rejections = [];
+
+    for (const variant of vector.representation_set.representations) {
+      if (variant.format_kind !== vector.target.format_kind) {
+        rejections.push({ representation_id: variant.representation_id, code: 'incompatible_format_kind' });
+        continue;
+      }
+      const firstAsset = Object.values(variant.assets)[0];
+      if (variant.format_kind === 'display_tag' &&
+          !vector.target.supported_delivery_types.includes(firstAsset.delivery_type)) {
+        rejections.push({ representation_id: variant.representation_id, code: 'unsupported_delivery_type' });
+        continue;
+      }
+      if (variant.format_kind === 'video_vast') {
+        const version = firstAsset.vast_version;
+        if (!vector.target.vast_versions.includes(version) || !vector.seller.vast_versions.includes(version)) {
+          rejections.push({ representation_id: variant.representation_id, code: 'vast_version_mismatch' });
+          continue;
+        }
+      }
+      compatible.push(variant);
+    }
+
+    const selected = vector.strategy === 'highest_compatible_vast'
+      ? compatible.reduce((best, candidate) => {
+          if (!best) return candidate;
+          const bestVersion = Number(Object.values(best.assets)[0].vast_version);
+          const candidateVersion = Number(Object.values(candidate.assets)[0].vast_version);
+          return candidateVersion > bestVersion ? candidate : best;
+        }, undefined)
+      : compatible[0];
+
+    assert.deepEqual(compatible.map(v => v.representation_id), vector.expected.compatible_representation_ids, vector.name);
+    assert.equal(selected?.representation_id ?? null, vector.expected.selected_representation_id, vector.name);
+    assert.deepEqual(vector.representation_set.representations.map(v => v.representation_id), vector.expected.retained_representation_ids, vector.name);
+    assert.deepEqual(rejections, vector.expected.rejections.map(({ representation_id, code }) => ({ representation_id, code })), vector.name);
+    if (!selected) {
+      const validateUnresolved = ajv.getSchema('/schemas/error-details/creative-representation-unresolved.json');
+      const details = { representation_rejections: vector.expected.rejections };
+      assert.equal(validateUnresolved(details), true,
+        `${vector.name}: ${JSON.stringify(validateUnresolved.errors)}`);
+      assert.equal(details.representation_rejections.length, vector.representation_set.representations.length,
+        `${vector.name}: unresolved resolution reports every retained candidate exactly once`);
+    }
+  }
+
+  const uniqueVariantIds = source => new Set(source.representations.map(variant => variant.representation_id)).size ===
+    source.representations.length;
+  assert.deepEqual(
+    validateSource.schema.properties.representations['x-adcp-validation'].unique_item_properties,
+    ['representation_id'],
+    'the published verifier contract declares variant identity uniqueness'
+  );
+  const duplicate = structuredClone(fixture.vectors[0].representation_set);
+  duplicate.representations[1].representation_id = duplicate.representations[0].representation_id;
+  assert.equal(uniqueVariantIds(duplicate), false, 'duplicate source representation IDs fail operational validation');
+
+  const exactRejectionCoverage = (source, rejections) => {
+    const candidateIds = source.representations.map(variant => variant.representation_id).toSorted();
+    const rejectionIds = rejections.map(rejection => rejection.representation_id).toSorted();
+    return new Set(rejectionIds).size === rejectionIds.length && isDeepStrictEqual(candidateIds, rejectionIds);
+  };
+  const allRejected = fixture.vectors[0].representation_set.representations.map(variant => ({
+    representation_id: variant.representation_id,
+    code: 'other',
+    message: 'incompatible'
+  }));
+  assert.equal(exactRejectionCoverage(fixture.vectors[0].representation_set, allRejected), true);
+  assert.equal(exactRejectionCoverage(fixture.vectors[0].representation_set, allRejected.slice(1)), false,
+    'unresolved details cannot omit a candidate');
+  assert.equal(exactRejectionCoverage(fixture.vectors[0].representation_set, [...allRejected, allRejected[0]]), false,
+    'unresolved details cannot duplicate a candidate');
+  const deliveryDetailsSchema = ajv.getSchema('/schemas/error-details/creative-representation-unresolved.json').schema;
+  assert.match(deliveryDetailsSchema['x-adcp-validation'].verifier_constraints.exact_candidate_coverage,
+    /no missing, duplicate, or unknown/);
+
+  const validateVariant = ajv.getSchema('/schemas/core/creative-representation.json');
+  const vastWithoutVersion = structuredClone(fixture.vectors[1].representation_set.representations[0]);
+  delete vastWithoutVersion.assets.vast_tag.vast_version;
+  assert.equal(validateVariant(vastWithoutVersion), false, 'late-bound VAST variants require exact asset versions');
+  const deprecatedNamedFormat = structuredClone(fixture.vectors[0].representation_set.representations[0]);
+  delete deprecatedNamedFormat.format_kind;
+  deprecatedNamedFormat.format_id = { agent_url: 'https://creative.adcontextprotocol.org', id: 'display_300x250' };
+  assert.equal(validateVariant(deprecatedNamedFormat), false,
+    'pre-binding representations require canonical format_kind and reject deprecated format_id');
+  const preboundOption = structuredClone(fixture.vectors[0].representation_set.representations[0]);
+  preboundOption.format_option_ref = { scope: 'product', format_option_id: 'paired_redirect_300x250' };
+  assert.equal(validateVariant(preboundOption), false,
+    'source representations cannot be pre-bound to one destination format option');
+  const nestedSelection = structuredClone(fixture.vectors[0].representation_set.representations[0]);
+  nestedSelection.representation_selection = {
+    creative_id: 'nested', revision_id: 'rev_nested', revision_content_digest: `sha256:${'0'.repeat(64)}`,
+    selected_representation_id: 'nested', strategy: 'representation_order',
+    selected_output_digest: `sha256:${'1'.repeat(64)}`, resolved_by: 'buyer'
+  };
+  assert.equal(validateVariant(nestedSelection), false,
+    'source representations cannot recursively carry prior selection lineage');
+
+  const validateSelection = ajv.getSchema('/schemas/core/representation-selection.json');
+  const selectedSet = fixture.vectors[0].representation_set;
+  const selectedRepresentation = selectedSet.representations.find(rep =>
+    rep.representation_id === fixture.vectors[0].expected.selected_representation_id);
+  const selectedOutputProjection = value => {
+    const projected = structuredClone(value);
+    for (const key of [
+      '$schema', 'representation_selection', 'creative_id', 'revision_id', 'name', 'tags',
+      'status', 'weight', 'placement_refs', 'placement_ids', 'inputs'
+    ]) delete projected[key];
+    return projected;
+  };
+  const selectedOutputDigestFor = value =>
+    `sha256:${crypto.createHash('sha256').update(canonicalize(selectedOutputProjection(value))).digest('hex')}`;
+  const derivedManifest = {
+    format_kind: selectedRepresentation.format_kind,
+    format_option_ref: { scope: 'product', format_option_id: 'paired_redirect_300x250' },
+    assets: selectedRepresentation.assets
+  };
+  const selectedOutputDigest = selectedOutputDigestFor(derivedManifest);
+  const selection = {
+    creative_id: selectedSet.creative_id,
+    revision_id: selectedSet.revision_id,
+    revision_content_digest: selectedSet.revision_content_digest,
+    selected_representation_id: fixture.vectors[0].expected.selected_representation_id,
+    strategy: 'representation_order',
+    selected_output_digest: selectedOutputDigest,
+    resolved_by: 'seller'
+  };
+  assert.equal(validateSelection(selection), true, JSON.stringify(validateSelection.errors));
+  const selectionWithoutDigest = { ...selection };
+  delete selectionWithoutDigest.revision_content_digest;
+  assert.equal(validateSelection(selectionWithoutDigest), false,
+    'selected output always retains its complete-set revision binding');
+  assert.equal(validateSelection.schema.properties.revision_id.$ref,
+    '/schemas/core/creative-revision-id.json');
+  assert.equal(validateSelection.schema.properties.selected_representation_id['x-entity'],
+    'creative_representation');
+  assert.equal(validateSelection.schema.properties.strategy.$ref,
+    '/schemas/enums/representation-selection-strategy.json');
+
+  const syncSchema = ajv.getSchema('/schemas/creative/sync-creatives-request.json').schema;
+  const revisionRules = syncSchema.properties.creatives.items.allOf[1]['x-adcp-validation']
+    .verifier_constraints.revision_identity;
+  assert.match(revisionRules.representation_set_projection.source_revision_binding, /complete representation-set fingerprint/);
+  assert.match(revisionRules.representation_set_projection.source_revision_binding, /MUST NOT fingerprint only the selected manifest/);
+  assert.match(revisionRules.representation_set_projection.execution_change, /ordinary re-review/);
+  assert.match(revisionRules.representation_set_projection.explicit_reselection, /buyer-submitted sync_creatives/);
+  assert.match(revisionRules.representation_set_projection.explicit_reselection, /build_creative resolution alone does not mutate/);
+  assert.match(revisionRules.representation_set_projection.capability_drift, /MUST NOT implicitly re-resolve/);
+  assert.match(revisionRules.representation_set_projection.seller_inability, /MUST NOT silently substitute/);
+  assert.match(validateSource.schema['x-adcp-validation'].verifier_constraints.revision_identity.equivalence_assertion,
+    /buyer asserts.*digest proves set integrity, not semantic or rendered equivalence/);
+  assert.equal(validateSelection.schema['x-adcp-validation'].spec,
+    'docs/creative/representation-sets.mdx#seller-bound-resolution');
+  const selectionRules = validateSelection.schema['x-adcp-validation'].verifier_constraints.derived_output;
+  assert.match(selectionRules.approval_boundary, /exact selected output MUST complete.*ordinary validation and review/);
+  assert.match(selectionRules.runtime_selection, /pinned at trafficking time.*MUST NOT be changed per viewer or device/);
+  assert.match(selectionRules.selection_stability, /only an explicit buyer-submitted selected output/);
+  assert.match(selectionRules.seller_inability, /media-buy impairment/);
+
+  const validateBuild = ajv.getSchema('/schemas/media-buy/build-creative-request.json');
+  const resolutionRequest = {
+    idempotency_key: 'resolve-source-0001',
+    creative_representation_set: fixture.vectors[0].representation_set,
+    representation_destination: {
+      product_id: 'prod_display_1',
+      format_option: {
+        format_option_id: 'paired_redirect_300x250',
+        format_kind: 'display_tag',
+        params: { supported_delivery_types: ['paired_redirect'] }
+      }
+    },
+    representation_selection_strategy: 'representation_order',
+    target_capability_id: 'paired_redirect_300x250'
+  };
+  assert.equal(validateBuild(resolutionRequest), true, JSON.stringify(validateBuild.errors));
+  assert.equal(validateBuild({ ...resolutionRequest, macro_values: { CACHEBUSTER: '123' } }), true,
+    'selection precedes binding and the complete representation set remains unchanged');
+  for (const forbidden of [
+    { message: 'make it punchier' },
+    { max_variants: 2 },
+    { transformer_id: 'transformer_1' },
+    { target_capability_ids: ['paired_redirect_300x250'] },
+    { brand: { domain: 'nova.example' } },
+    { media_buy_id: 'buy_1' },
+    { package_id: 'pkg_1' }
+  ]) {
+    assert.equal(validateBuild({ ...resolutionRequest, ...forbidden }), false,
+      `pure representation resolution rejects ${Object.keys(forbidden)[0]}`);
+  }
+  const missingDestination = { ...resolutionRequest };
+  delete missingDestination.representation_destination;
+  assert.equal(validateBuild(missingDestination), false,
+    'seller-bound resolution requires an explicit product format context');
+  const missingStrategy = { ...resolutionRequest };
+  delete missingStrategy.representation_selection_strategy;
+  assert.equal(validateBuild(missingStrategy), false,
+    'representation strategy is explicit and replayable');
+  assert.equal(validateBuild({ ...resolutionRequest, representation_selection_strategy: 'highest_compatible_vast' }), false,
+    'highest-compatible VAST strategy is invalid for a non-VAST destination');
+
+  derivedManifest.representation_selection = selection;
+  const validateBuildResponse = ajv.getSchema('/schemas/media-buy/build-creative-response.json');
+  assert.equal(validateBuildResponse({ status: 'completed', creative_manifest: derivedManifest }), true,
+    JSON.stringify(validateBuildResponse.errors));
+  const responseRules = validateBuildResponse.schema['x-adcp-validation']
+    .verifier_constraints.representation_resolution_response;
+  assert.match(responseRules.lineage_required, /representation_selection MUST be present/);
+  assert.match(responseRules.build_variant_id, /MUST be absent/);
+  assert.match(responseRules.resolver_actor, /MUST equal seller/);
+  assert.equal(derivedManifest.representation_selection.resolved_by, 'seller');
+  const hasSellerResolutionActor = response =>
+    response.creative_manifest?.representation_selection?.resolved_by === 'seller';
+  assert.equal(hasSellerResolutionActor({ creative_manifest: derivedManifest }), true);
+  assert.equal(hasSellerResolutionActor({
+    creative_manifest: {
+      ...derivedManifest,
+      representation_selection: { ...selection, resolved_by: 'buyer' }
+    }
+  }), false, 'seller-bound build response cannot attribute resolution to the buyer');
+  assert.equal(selection.selected_output_digest, selectedOutputDigest,
+    'selected-output digest binds the exact returned manifest projection');
+
+  const syncCreative = {
+    creative_id: selectedSet.creative_id,
+    revision_id: selectedSet.revision_id,
+    name: 'Library display launch',
+    tags: ['launch'],
+    status: 'pending_review',
+    weight: 100,
+    placement_refs: [{ publisher_domain: 'streamhaus.example', placement_id: 'homepage_mrec' }],
+    ...derivedManifest
+  };
+  const validateCreativeAsset = ajv.getSchema('/schemas/core/creative-asset.json');
+  assert.equal(validateCreativeAsset(syncCreative), true, JSON.stringify(validateCreativeAsset.errors));
+  const validateSyncCreative = ajv.compile(syncSchema.properties.creatives.items);
+  assert.equal(validateSyncCreative(syncCreative), true, JSON.stringify(validateSyncCreative.errors));
+  assert.equal(validateSyncCreative({ ...syncCreative, localization: null }), false,
+    'representation-selected sync items cannot remove localization outside the bound projections');
+  assert.equal(validateSyncCreative({
+    ...syncCreative,
+    localization: {
+      variants: [{
+        locale_variant_id: 'loc_en', locale: 'en', role: 'source', assets: syncCreative.assets
+      }],
+      default_locale_variant_id: 'loc_en'
+    }
+  }), false, 'representation-selected sync items cannot add materialized locale assets outside the bound projections');
+  const selectionSyncRules = syncSchema.properties.creatives.items.allOf
+    .find(branch => branch.if?.required?.includes('representation_selection'))
+    .then['x-adcp-validation'].verifier_constraints;
+  assert.equal(selectionSyncRules.prior_stored_localization, 'must_be_absent');
+  assert.match(selectionSyncRules.on_existing_localization, /reject_before_mutation/);
+  const canApplyRepresentationSelection = priorCreative => priorCreative.localization === undefined;
+  assert.equal(canApplyRepresentationSelection({ ...syncCreative }), true);
+  assert.equal(canApplyRepresentationSelection({
+    ...syncCreative,
+    localization: {
+      variants: [{
+        locale_variant_id: 'loc_en', locale: 'en', role: 'source', assets: syncCreative.assets
+      }],
+      default_locale_variant_id: 'loc_en'
+    }
+  }), false, 'stored localization must be removed in a prior accepted sync before selection lineage can be applied');
+  assert.equal(selectedOutputDigestFor(syncCreative), selectedOutputDigest,
+    'build manifest and legal sync wrapper use one selected-output projection');
+  const metadataOnlyUpdate = {
+    ...syncCreative,
+    name: 'Renamed library creative',
+    tags: ['renamed'],
+    weight: 25,
+    placement_refs: [{ publisher_domain: 'streamhaus.example', placement_id: 'article_mrec' }]
+  };
+  assert.equal(selectedOutputDigestFor(metadataOnlyUpdate), selectedOutputDigest,
+    'library metadata and routing changes do not alter selected-output identity');
+  const changedExecution = structuredClone(syncCreative);
+  changedExecution.assets.serving_tag.clickthrough_url = 'https://click.acme-example.com/changed';
+  assert.notEqual(selectedOutputDigestFor(changedExecution), selectedOutputDigest,
+    'changed delivery bytes alter selected-output identity and trigger review');
+
+  const registry = JSON.parse(fs.readFileSync(path.join(SCHEMAS, 'index.json'), 'utf8'));
+  for (const publicSchema of [
+    'creative-representation-set', 'creative-representation', 'representation-destination',
+    'representation-selection', 'representation-rejection', 'macro-bearing-url',
+    'macro-declaration', 'macro-encoding', 'macro-resolution-capability',
+    'macro-resolution-result', 'macro-translation-target'
+  ]) {
+    assert.ok(registry.schemas.core.schemas[publicSchema], `${publicSchema} is discoverable in the schema registry`);
+  }
+  assert.ok(registry.schemas.enums.schemas['representation-selection-strategy'],
+    'representation selection strategy is discoverable in the schema registry');
+});
+
+test('macro processing vectors preserve bytes and match exact owner/context/encoding contracts', () => {
+  const fixture = JSON.parse(fs.readFileSync(MACRO_VECTORS, 'utf8'));
+  const validateFixture = ajv.compile(JSON.parse(fs.readFileSync(MACRO_VECTOR_SCHEMA, 'utf8')));
+  assert.equal(validateFixture(fixture), true, JSON.stringify(validateFixture.errors));
+
+  const encodingEqual = (left, right) => left.kind === right.kind && left.depth === right.depth;
+  const evaluateLayer = (declaration, capabilities) => {
+    let candidates = capabilities.filter(capability => capability.dialect === declaration.dialect);
+    if (!candidates.length) return 'dialect_unsupported';
+    candidates = candidates.filter(capability => capability.dialect_namespace === declaration.dialect_namespace);
+    if (!candidates.length) return 'namespace_mismatch';
+    candidates = candidates.filter(capability => capability.dialect_revision === declaration.dialect_revision);
+    if (!candidates.length) return 'revision_mismatch';
+    candidates = candidates.filter(capability =>
+      capability.dialect_semantic === declaration.dialect_semantic &&
+      capability.universal_semantic === declaration.universal_semantic
+    );
+    if (!candidates.length) return 'semantic_unsupported';
+    candidates = candidates.filter(capability => capability.operation === declaration.operation);
+    if (!candidates.length) return 'operation_unsupported';
+    candidates = candidates.filter(capability => capability.performed_by === declaration.performed_by);
+    if (!candidates.length) return 'resolver_mismatch';
+    candidates = candidates.filter(capability => capability.supported_contexts.includes(declaration.location.context));
+    if (!candidates.length) return 'context_unsupported';
+    if (declaration.operation === 'translate_to_native') {
+      candidates = candidates.filter(capability =>
+        isDeepStrictEqual(capability.translation_target, declaration.translation_target)
+      );
+      return candidates.length ? null : 'semantic_unsupported';
+    }
+    candidates = candidates.filter(capability =>
+      capability.supported_encodings?.some(encoding => encodingEqual(encoding, declaration.encoding))
+    );
+    return candidates.length ? null : 'encoding_unsupported';
+  };
+  const strictRfc3986 = value => encodeURIComponent(value).replace(/[!'()*]/g, char =>
+    `%${char.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+
+  for (const vector of fixture.vectors) {
+    const declaration = vector.declaration;
+    let status;
+    let reason;
+    let output = vector.source;
+
+    if (declaration.operation === 'preserve') {
+      status = 'preserved_for_downstream';
+      reason = declaration.dialect === 'unknown' ? 'preserved_unknown' : 'preserved_for_downstream';
+    } else {
+      reason = evaluateLayer(declaration, vector.seller_capabilities) ||
+        evaluateLayer(declaration, vector.product_capabilities);
+      if (reason) {
+        status = 'unsupported';
+      } else {
+        status = 'resolvable';
+        reason = 'capability_match';
+        if (declaration.operation === 'translate_to_native') {
+          const target = declaration.translation_target;
+          const emittedDeclaration = {
+            declaration_id: declaration.declaration_id,
+            token: target.token,
+            dialect: target.dialect,
+            ...(target.dialect_namespace && { dialect_namespace: target.dialect_namespace }),
+            ...(target.dialect_revision && { dialect_revision: target.dialect_revision }),
+            dialect_semantic: target.dialect_semantic,
+            mapping_status: target.mapping_status,
+            ...(target.universal_semantic && { universal_semantic: target.universal_semantic }),
+            operation: target.next_operation,
+            performed_by: target.performed_by,
+            location: structuredClone(declaration.location),
+            encoding: structuredClone(target.encoding),
+            required: declaration.required,
+            unavailable_behavior: declaration.unavailable_behavior
+          };
+          const chainReason = evaluateLayer(emittedDeclaration, vector.seller_capabilities) ||
+            evaluateLayer(emittedDeclaration, vector.product_capabilities);
+          if (chainReason) {
+            status = 'unsupported';
+            reason = chainReason;
+          } else {
+            output = output.replace(declaration.token, target.token);
+            if (vector.expected.emitted_declaration) {
+              assert.deepEqual(emittedDeclaration, vector.expected.emitted_declaration, vector.name);
+            }
+            if (vector.value !== undefined && vector.expected.final_output) {
+              const encoded = strictRfc3986(vector.value);
+              const finalOutput = output.replace(target.token, encoded);
+              assert.equal(finalOutput, vector.expected.final_output, vector.name);
+            }
+          }
+        } else if (vector.value !== undefined && declaration.operation === 'resolve_value') {
+          let encoded = vector.value;
+          if (declaration.encoding.kind === 'rfc3986') {
+            for (let pass = 0; pass < declaration.encoding.depth; pass++) encoded = strictRfc3986(encoded);
+          }
+          output = output.replace(declaration.token, encoded);
+        }
+      }
+    }
+
+    assert.equal(status, vector.expected.status, vector.name);
+    assert.equal(reason, vector.expected.reason, vector.name);
+    assert.equal(output, vector.expected.output, vector.name);
+  }
+
+  const declarationIdsAreUnique = declarations =>
+    new Set(declarations.map(declaration => declaration.declaration_id)).size === declarations.length;
+  const firstDeclaration = fixture.vectors[0].declaration;
+  const declarations = [
+    firstDeclaration,
+    { ...structuredClone(firstDeclaration), declaration_id: 'second-occurrence' }
+  ];
+  assert.equal(declarationIdsAreUnique(declarations), true);
+  assert.equal(declarationIdsAreUnique([...declarations, structuredClone(firstDeclaration)]), false,
+    'duplicate declaration IDs fail occurrence-level operational validation');
+
+  const translationVector = fixture.vectors.find(vector => vector.declaration.operation === 'translate_to_native');
+  assert.ok(translationVector);
+  assert.equal(translationVector.seller_capabilities.length, 2, 'translation requires source and target capability tuples');
+  assert.equal(translationVector.product_capabilities.length, 2, 'the selected product also closes the target chain');
+  const coveredReasons = new Set(fixture.vectors.map(vector => vector.expected.reason));
+  const reasonEnum = ajv.getSchema('/schemas/enums/macro-resolution-reason.json').schema.enum;
+  assert.deepEqual(
+    reasonEnum.filter(reason => reason !== 'ambiguous_mapping' && !coveredReasons.has(reason)),
+    [],
+    'portable processing vectors cover every deterministic match, preservation, and unsupported reason'
+  );
+});
+
+test('validation and sync response schemas expose per-token macro results', () => {
+  const validateInputResultSchema = ajv.getSchema('/schemas/creative/validate-input-result.json').schema;
+  const syncResponse = ajv.getSchema('/schemas/creative/sync-creatives-response.json').schema;
+  assert.equal(validateInputResultSchema.properties.macro_resolution_results.items.$ref, '/schemas/core/macro-resolution-result.json');
+  const syncItem = syncResponse.oneOf[0].properties.creatives.items;
+  assert.equal(syncItem.properties.macro_resolution_results.items.$ref, '/schemas/core/macro-resolution-result.json');
+
+  const validateResult = ajv.getSchema('/schemas/core/macro-resolution-result.json');
+  const unknownResult = {
+    declaration_id: 'unknown-token',
+    asset_path: '/assets/impression_tracker',
+    token: '%%UNIDENTIFIED%%',
+    dialect: 'unknown',
+    dialect_semantic: 'unresolved',
+    mapping_status: 'unresolved',
+    operation: 'preserve',
+    requested_encoding: { kind: 'none', depth: 0 },
+    required: false,
+    unavailable_behavior: 'preserve',
+    status: 'preserved_for_downstream',
+    reason: 'preserved_unknown'
+  };
+  assert.equal(validateResult(unknownResult), true, JSON.stringify(validateResult.errors));
+  assert.equal(validateResult({ ...unknownResult, status: 'resolvable', reason: 'capability_match' }), false);
+  assert.equal(validateResult({ ...unknownResult, status: 'unsupported', reason: 'capability_match' }), false);
+  assert.equal(validateResult({
+    ...unknownResult,
+    dialect: 'adcp',
+    dialect_semantic: 'CACHEBUSTER',
+    mapping_status: 'verified_universal',
+    universal_semantic: 'CACHEBUSTER',
+    operation: 'resolve_value',
+    performed_by: 'seller',
+    requested_encoding: { kind: 'rfc3986', depth: 1 },
+    status: 'preserved_for_downstream',
+    reason: 'preserved_for_downstream'
+  }), false, 'an advertised resolver is resolvable or unsupported, never a preservation result');
+  const daastResult = {
+    declaration_id: 'daast-error',
+    asset_path: '/assets/error_tracker',
+    token: '[ERRORCODE]',
+    dialect: 'iab_daast',
+    dialect_namespace: 'https://iabtechlab.com/standards/daast',
+    dialect_revision: 'DAAST-1.1',
+    dialect_semantic: 'ERRORCODE',
+    mapping_status: 'dialect_defined',
+    operation: 'resolve_value',
+    performed_by: 'request_executor',
+    requested_encoding: { kind: 'rfc3986', depth: 1 },
+    required: true,
+    unavailable_behavior: 'reject',
+    status: 'resolvable',
+    reason: 'capability_match'
+  };
+  assert.equal(validateResult(daastResult), true, JSON.stringify(validateResult.errors));
+  assert.equal(validateResult({ ...daastResult, performed_by: 'seller' }), false);
+  const ambiguousResult = {
+    ...daastResult,
+    status: 'ambiguous',
+    reason: 'ambiguous_mapping',
+    message: 'Two declarations claim the same token occurrence with different meanings'
+  };
+  assert.equal(validateResult(ambiguousResult), true, JSON.stringify(validateResult.errors));
+  assert.equal(validateResult({ ...ambiguousResult, reason: 'semantic_unsupported' }), false,
+    'ambiguous occurrence identity has one machine-stable reason distinct from unsupported matching');
+});
+
+test('macro processing capabilities bind at the format-option layer, not canonical params', () => {
+  const capability = {
+    dialect: 'adcp',
+    dialect_semantic: 'CACHEBUSTER',
+    mapping_status: 'verified_universal',
+    universal_semantic: 'CACHEBUSTER',
+    operation: 'resolve_value',
+    performed_by: 'seller',
+    supported_contexts: ['url_query_value'],
+    supported_encodings: [{ kind: 'rfc3986', depth: 1 }]
+  };
+  const declaration = {
+    format_option_id: 'vast-with-macros',
+    format_kind: 'video_vast',
+    macro_resolution_capabilities: [capability],
+    params: { vast_versions: ['4.2'] }
+  };
+
+  const validateDeclaration = ajv.getSchema('/schemas/core/product-format-declaration.json');
+  const validateCompact = ajv.getSchema('/schemas/core/canonical-format-option.json');
+  const validateVastParams = ajv.getSchema('/schemas/formats/canonical/video_vast.json');
+  assert.equal(validateDeclaration(declaration), true, JSON.stringify(validateDeclaration.errors));
+  assert.equal(validateCompact(declaration), true, JSON.stringify(validateCompact.errors));
+  assert.equal(validateVastParams({
+    vast_versions: ['4.2'],
+    macro_resolution_capabilities: [capability]
+  }), false, 'execution capabilities must not be repeated through every canonical params branch');
+
+  const base = ajv.getSchema('/schemas/formats/canonical/_base.json').schema;
+  assert.equal(base.properties.macro_resolution_capabilities, undefined);
+  assert.deepEqual(base.not, { required: ['macro_resolution_capabilities'] });
+  assert.equal(validateDeclaration.schema.properties.macro_resolution_capabilities.items.$ref,
+    '/schemas/core/macro-resolution-capability.json');
+  assert.equal(validateCompact.schema.properties.macro_resolution_capabilities.items.$ref,
+    '/schemas/core/macro-resolution-capability.json');
+});
+
+test('creative delivery errors use typed detail schemas without closing the generic extension point', () => {
+  const genericDetails = ajv.getSchema('/schemas/core/error.json').schema.properties.details;
+  assert.equal(genericDetails.additionalProperties, true);
+  assert.equal(genericDetails.properties, undefined,
+    'error.details stays a pure extension point selected by error code');
+
+  const validateDeliveryDetails = ajv.getSchema(
+    '/schemas/error-details/creative-representation-unresolved.json'
+  );
+  const deliveryDetails = {
+    representation_rejections: [{
+      representation_id: 'source-vast-2',
+      code: 'vast_version_mismatch',
+      message: 'VAST 2.0 is outside the compatibility intersection'
+    }]
+  };
+  assert.equal(validateDeliveryDetails(deliveryDetails), true,
+    JSON.stringify(validateDeliveryDetails.errors));
+  assert.equal(validateDeliveryDetails({}), false);
+
+  const validateMacroDetails = ajv.getSchema('/schemas/error-details/macro-resolution-failed.json');
+  assert.equal(ajv.getSchema('/schemas/core/macro-declaration.json').schema.properties.declaration_id['x-entity'],
+    'macro_declaration');
+  assert.equal(ajv.getSchema('/schemas/core/macro-resolution-result.json').schema.properties.declaration_id['x-entity'],
+    'macro_declaration');
+  assert.ok(ajv.getSchema('/schemas/core/x-entity-types.json').schema.enum.includes('macro_declaration'));
+  const macroDetails = {
+    macro_resolution_results: [{
+      declaration_id: 'unknown-token',
+      asset_path: '/assets/impression_tracker',
+      token: '%%UNIDENTIFIED%%',
+      dialect: 'unknown',
+      dialect_semantic: 'unresolved',
+      mapping_status: 'unresolved',
+      operation: 'preserve',
+      requested_encoding: { kind: 'none', depth: 0 },
+      required: false,
+      unavailable_behavior: 'preserve',
+      status: 'preserved_for_downstream',
+      reason: 'preserved_unknown'
+    }]
+  };
+  assert.equal(validateMacroDetails(macroDetails), true, JSON.stringify(validateMacroDetails.errors));
+  assert.equal(validateMacroDetails({}), false);
+
+  const validateVastDetails = ajv.getSchema('/schemas/error-details/vast-version-mismatch.json');
+  const vastDetails = {
+    mismatch_reason: 'asset_outside_acceptance',
+    asset_vast_version: '4.0',
+    product_vast_versions: ['4.1', '4.2'],
+    seller_vast_versions: ['4.0', '4.1'],
+    format_option_ref: { scope: 'product', format_option_id: 'video-preroll' }
+  };
+  assert.equal(validateVastDetails(vastDetails), true, JSON.stringify(validateVastDetails.errors));
+  assert.equal(validateVastDetails({ ...vastDetails, format_option_ref: undefined }), true,
+    'a unique id-less product option has no format option reference to invent');
+  assert.equal(validateVastDetails({ ...vastDetails, product_vast_versions: [] }), false,
+    'advertised product acceptance sets cannot be empty');
+  assert.equal(validateVastDetails({ ...vastDetails, seller_vast_versions: [] }), false,
+    'advertised seller acceptance sets cannot be empty');
+  assert.equal(validateVastDetails({
+    mismatch_reason: 'document_version_mismatch',
+    asset_vast_version: '4.0',
+    observed_document_vast_version: '5.0',
+    document_role: 'submitted'
+  }), true, JSON.stringify(validateVastDetails.errors));
+  assert.equal(validateVastDetails({
+    mismatch_reason: 'document_version_mismatch',
+    asset_vast_version: '4.0',
+    observed_document_vast_version: null,
+    document_role: 'submitted'
+  }), true, 'a missing VAST version attribute remains representable');
+  const wrapperMismatch = {
+    mismatch_reason: 'document_version_mismatch',
+    asset_vast_version: '4.0',
+    observed_document_vast_version: '3.0',
+    document_role: 'wrapper',
+    product_vast_versions: ['4.0', '4.1'],
+    seller_vast_versions: ['4.0', '4.2']
+  };
+  assert.equal(validateVastDetails(wrapperMismatch), true, JSON.stringify(validateVastDetails.errors));
+  assert.equal(validateVastDetails({ ...wrapperMismatch, product_vast_versions: undefined }), false,
+    'wrapper mismatch details must disclose both acceptance sets used as the comparator');
+  assert.equal(validateVastDetails({ ...wrapperMismatch, seller_vast_versions: undefined }), false,
+    'terminal and wrapper mismatch details cannot omit the seller acceptance set');
+  assert.equal(validateVastDetails({ supported_versions: ['3.0', '4.0'] }), true,
+    'deprecated 3.x details remain accepted');
+  assert.equal(validateVastDetails({ mismatch_reason: 'asset_outside_acceptance', asset_vast_version: '4.0' }), false);
+});
diff --git a/tests/creative-revisions.test.cjs b/tests/creative-revisions.test.cjs
new file mode 100644
index 0000000000..aa08943478
--- /dev/null
+++ b/tests/creative-revisions.test.cjs
@@ -0,0 +1,210 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+const Ajv = require('ajv');
+const addFormats = require('ajv-formats');
+
+const SCHEMA_DIR = path.join(__dirname, '../static/schemas/source');
+
+function schema(relativePath) {
+  return JSON.parse(fs.readFileSync(path.join(SCHEMA_DIR, relativePath), 'utf8'));
+}
+
+async function compile(relativePath) {
+  const ajv = new Ajv({
+    allErrors: true,
+    strict: false,
+    loadSchema: async uri => schema(uri.replace(/^\/schemas\//, '').split('#', 1)[0])
+  });
+  addFormats(ajv);
+  return ajv.compileAsync(schema(relativePath));
+}
+
+const revisionId = 'rev_2026_08_23_01';
+
+test('sync request accepts scoped revision identity and publishes fail-closed content rules', async () => {
+  const validate = await compile('creative/sync-creatives-request.json');
+  const request = {
+    idempotency_key: '550e8400-e29b-41d4-a716-446655440000',
+    account: { account_id: 'acct_acme' },
+    creatives: [{
+      creative_id: 'hero',
+      revision_id: revisionId,
+      name: 'Hero',
+      format_kind: 'image',
+      assets: {
+        image: {
+          asset_type: 'image',
+          url: 'https://cdn.example/hero.png',
+          width: 300,
+          height: 250
+        }
+      }
+    }]
+  };
+  assert.equal(validate(request), true, JSON.stringify(validate.errors));
+
+  const rules = schema('creative/sync-creatives-request.json')
+    .properties.creatives.items.allOf[1]['x-adcp-validation'].verifier_constraints.revision_identity;
+  assert.deepEqual(rules.scope, ['creative_id', 'revision_id']);
+  assert.equal(rules.reliance_gate, 'creative.supports_revisions');
+  assert.deepEqual(rules.check_order, ['idempotency_key', 'revision_content']);
+  assert.equal(rules.canonical_content.included, 'all effective buyer-authored creative fields, including unknown future content fields');
+  assert.equal(
+    rules.canonical_content.canonicalization,
+    'RFC_8785_JCS_of_effective_buyer_state_after_removing_exact_top_level_excluded_fields'
+  );
+  assert.equal(rules.canonical_content.exclusion_scope, 'top_level_creative_item_only');
+  assert.equal(rules.canonical_content.duplicate_json_members, 'reject_request_before_comparison');
+  assert.equal(
+    rules.canonical_content.localization_null,
+    'remove_localization_property_from_effective_state_before_comparison'
+  );
+  assert.equal(rules.same_revision_different_content, 'CREATIVE_REVISION_CONTENT_MISMATCH');
+  assert.equal(
+    rules.first_revision_on_unversioned_creative.same_effective_content,
+    'accept_as_updated_bind_revision_and_preserve_review_state'
+  );
+  assert.equal(
+    rules.first_revision_on_unversioned_creative.different_effective_content,
+    'bind_only_on_accepted_update_and_require_review'
+  );
+  assert.equal(
+    rules.different_revision_same_current_content,
+    'accept_as_updated_make_current_preserve_review_state_and_rebind_inflight_review'
+  );
+  assert.equal(
+    rules.revision_omitted_with_current_revision.different_effective_content,
+    'accept_under_legacy_update_rules_and_clear_current_revision_identity'
+  );
+  assert.equal(rules.revision_omitted_with_current_revision.must_not_mint_seller_revision, true);
+  assert.equal(
+    rules.revision_omitted_with_current_revision.different_effective_content_review,
+    'prior_approval_must_not_transfer_and_update_enters_ordinary_review'
+  );
+  assert.equal(
+    rules.stale_review_result.different_fingerprint_or_not_rebound,
+    'must_not_mutate_current_revision_or_current_status'
+  );
+  assert.equal(
+    rules.stale_review_result.identical_content_rebound,
+    'apply_to_current_revision_and_attribute_result_and_webhook_to_current_revision_id'
+  );
+  assert.match(rules.dry_run, /do_not_create_or_update_bindings/);
+  assert.equal(rules.content_change_review, 'prior_approval_must_not_transfer');
+  assert.deepEqual(
+    schema('creative/sync-creatives-request.json').properties.creatives['x-adcp-validation'].unique_item_properties,
+    ['creative_id']
+  );
+});
+
+test('sync response echoes accepted revisions and forbids them on failed or deleted items', async () => {
+  const validate = await compile('creative/sync-creatives-response.json');
+  const accepted = {
+    status: 'completed',
+    creatives: [{ creative_id: 'hero', revision_id: revisionId, action: 'created' }]
+  };
+  assert.equal(validate(accepted), true, JSON.stringify(validate.errors));
+
+  for (const action of ['failed', 'deleted']) {
+    const invalid = {
+      status: 'completed',
+      creatives: [{ creative_id: 'hero', revision_id: revisionId, action }]
+    };
+    assert.equal(validate(invalid), false, `${action} unexpectedly retained revision_id`);
+  }
+
+  const item = schema('creative/sync-creatives-response.json').oneOf[0].properties.creatives.items;
+  const echo = item.allOf.at(-1)['x-adcp-validation'].verifier_constraints.revision_echo;
+  assert.equal(echo.required_capability, 'creative.supports_revisions');
+  assert.equal(echo.must_equal_request, true);
+  assert.deepEqual(echo.accepted_actions, ['created', 'updated', 'unchanged']);
+  assert.match(item.properties.revision_id.description, /without that capability may ignore/);
+});
+
+test('revision capability requires a creative library', async () => {
+  const validate = await compile('protocol/get-adcp-capabilities-response.json');
+  const base = {
+    status: 'completed',
+    adcp: {
+      major_versions: [3],
+      idempotency: { supported: true, replay_ttl_seconds: 86400 }
+    },
+    supported_protocols: ['creative'],
+    creative: { has_creative_library: true, supports_revisions: true }
+  };
+  assert.equal(validate(base), true, JSON.stringify(validate.errors));
+
+  for (const library of [false, undefined]) {
+    const invalid = structuredClone(base);
+    if (library === undefined) delete invalid.creative.has_creative_library;
+    else invalid.creative.has_creative_library = library;
+    assert.equal(validate(invalid), false, `supports_revisions accepted has_creative_library=${library}`);
+  }
+});
+
+test('revision identity reads back through library, webhook, and delivery schemas', async () => {
+  const registry = schema('core/x-entity-types.json');
+  assert.ok(registry.enum.includes('creative_revision'));
+  assert.ok(registry.enum.includes('served_variant'));
+
+  const listSchema = schema('creative/list-creatives-response.json');
+  assert.equal(
+    listSchema.properties.creatives.items.properties.revision_id.$ref,
+    '/schemas/core/creative-revision-id.json'
+  );
+  assert.equal(
+    listSchema.properties.creatives.items.properties.revision_id['x-adcp-validation']
+      .verifier_constraints.revision_readback.must_equal,
+    'last_accepted_current_buyer_revision'
+  );
+  const webhookRevision = schema('creative/creative-status-changed-webhook.json').properties.revision_id;
+  assert.equal(
+    webhookRevision.$ref,
+    '/schemas/core/creative-revision-id.json'
+  );
+  assert.equal(
+    webhookRevision['x-adcp-validation'].verifier_constraints.revision_transition_attribution.must_equal,
+    'revision_to_which_transition_applies'
+  );
+
+  const validateVariant = await compile('core/creative-variant.json');
+  assert.equal(validateVariant({ variant_id: 'served_1', revision_id: revisionId }), true, JSON.stringify(validateVariant.errors));
+  assert.equal(schema('core/creative-variant.json').allOf[1].properties.variant_id['x-entity'], 'served_variant');
+  assert.equal(schema('creative/preview-creative-request.json').properties.variant_id['x-entity'], 'served_variant');
+  const attribution = schema('core/creative-variant.json').allOf[1].properties.revision_id['x-adcp-validation']
+    .verifier_constraints.revision_attribution;
+  assert.equal(attribution.row_metrics_revision_homogeneous, true);
+  assert.equal(attribution.current_list_revision_not_required, true);
+  const rows = schema('creative/get-creative-delivery-response.json').properties.creatives.items
+    .properties.variants['x-adcp-validation'].verifier_constraints.revision_homogeneous_rows;
+  assert.deepEqual(rows.row_key, ['variant_id']);
+  assert.equal(rows.row_key_unique, true);
+  assert.equal(rows.variant_id_scope.default, 'unique_within_agent_and_creative');
+  assert.equal(rows.variant_id_scope.when_creative_supports_revisions,
+    'agent_unique_immutable_and_unambiguous_for_variant_preview_when_supported');
+  const variantIdentity = schema('core/creative-variant.json').allOf[1].properties.variant_id['x-adcp-validation']
+    .verifier_constraints;
+  assert.equal(variantIdentity.default_scope, 'unique_within_agent_and_creative');
+  assert.match(variantIdentity.when_creative_supports_revisions, /agent_unique/);
+  assert.equal(rows.metrics_must_not_cross_revision_boundary, true);
+  assert.equal(rows.metrics_must_not_cross_locale_boundary, true);
+});
+
+test('revision mismatch has a typed correctable error contract', async () => {
+  const validate = await compile('error-details/creative-revision-content-mismatch.json');
+  assert.equal(validate({ creative_id: 'hero', revision_id: revisionId }), true, JSON.stringify(validate.errors));
+  assert.equal(validate({ creative_id: 'hero' }), false);
+
+  const errors = schema('enums/error-code.json');
+  assert.ok(errors.enum.includes('CREATIVE_REVISION_CONTENT_MISMATCH'));
+  assert.equal(errors.enumMetadata.CREATIVE_REVISION_CONTENT_MISMATCH.recovery, 'correctable');
+
+  const scenario = fs.readFileSync(path.join(
+    SCHEMA_DIR,
+    '../../compliance/source/protocols/creative/scenarios/creative_revision_identity.yaml'
+  ), 'utf8');
+  assert.match(scenario, /path: "creatives\[0\]\.errors\[0\]\.code"/,
+    'best-effort mismatch validation must inspect the per-creative error');
+});
diff --git a/tests/mcp-schema-projection.test.cjs b/tests/mcp-schema-projection.test.cjs
index 9a89d0607a..7996a78e86 100644
--- a/tests/mcp-schema-projection.test.cjs
+++ b/tests/mcp-schema-projection.test.cjs
@@ -43,6 +43,14 @@ const STORYBOARD_DIR = path.join(REPO_ROOT, 'static', 'compliance', 'source');
 const LATEST_DIR = path.join(REPO_ROOT, 'dist', 'schemas', 'latest');
 const PROJECTION_DIR = path.join(LATEST_DIR, 'mcp', MCP_PROTOCOL_VERSION);
 const PRODUCTION_PROFILE_DIR = path.join(PROJECTION_DIR, 'profiles', 'production');
+// Macro occurrence contracts and representation-set resolution add shared,
+// structurally enforced graphs to media-buy tasks. Keep those measured
+// increases isolated from the creative profile and retain main's 400 KiB hard
+// ceiling while the shared-dictionary projection is still experimental.
+const MODEL_CONTEXT_BUDGET_KIB = {
+  'media-buy': 400,
+  creative: 400,
+};
 // Keep parity compilation materially tighter than the 4 MiB protocol schema
 // bound while allowing example-bearing schemas to carry the complete Product
 // targeting contract. The test below still compiles both dialects and executes
@@ -1148,13 +1156,11 @@ test('generated role profiles are host-compatible discovery catalogs with bounde
       assert.ok(fs.existsSync(modelInputPath));
       modelContextBytes += Buffer.byteLength(JSON.stringify(readJson(modelInputPath)));
     }
-    // Budget raised from 384 KiB: main reached 139 bytes of headroom within a
-    // day of the budget landing (each schema-bearing feature costs ~1-2 KiB of
-    // inlined model context). 400 KiB buys room until the shared-dictionary
-    // projection graduates and collapses per-tool inlining.
+    const modelContextBudgetKib = MODEL_CONTEXT_BUDGET_KIB[profileName];
+    assert.ok(modelContextBudgetKib, `missing model-context budget for ${profileName}`);
     assert.ok(
-      modelContextBytes < 400 * 1024,
-      `${profileName} model-context inputs exceed 400 KiB: ${modelContextBytes}`
+      modelContextBytes < modelContextBudgetKib * 1024,
+      `${profileName} model-context inputs exceed ${modelContextBudgetKib} KiB: ${modelContextBytes}`
     );
   }