@adcp/sdk 13.0.0-rc.10 → 13.0.0-rc.13

package/dist/lib/schemas-data/v2.5/_provenance.json

@@ -4,5 +4,5 @@
   "source_sha": "4e553ad955f83b49c7d221ab5c3ff78237ad02e3",
   "source_tarball_sha256": "580656d6466ef9f0d1119985e6726c2efea718dc671e2ad30957fcb2fd54af0f",
   "upstream_adcp_version": "2.5.3",
-  "synced_at": "2026-08-08T20:24:25.236Z"
+  "synced_at": "2026-08-10T05:48:43.171Z"
 }

package/dist/lib/server/decisioning/runtime/from-platform.d.mts

@@ -59,7 +59,7 @@ import type { PgQueryable } from '../../postgres-task-store.mjs';
 import { type TaskRegistry, type TaskRecord } from './task-registry.mjs';
 import { type StatusChangeBus } from '../status-changes.mjs';
 import { type ComplyControllerConfig } from '../../../testing/comply-controller.mjs';
-import type { LegacyFormatConverter } from '../../../v2/projection/v1-to-v2.mjs';
+import { type LegacyFormatConverter } from '../../../v2/projection/v1-to-v2.mjs';
 import type { CanonicalFormatLegacyResolver } from '../../../v2/projection/v2-to-v1.mjs';
 /**
  * Lifecycle observability hooks the v6 runtime fires at well-known points.

package/dist/lib/server/decisioning/runtime/from-platform.d.ts

@@ -59,7 +59,7 @@ import type { PgQueryable } from '../../postgres-task-store';
 import { type TaskRegistry, type TaskRecord } from './task-registry';
 import { type StatusChangeBus } from '../status-changes';
 import { type ComplyControllerConfig } from '../../../testing/comply-controller';
-import type { LegacyFormatConverter } from '../../../v2/projection/v1-to-v2';
+import { type LegacyFormatConverter } from '../../../v2/projection/v1-to-v2';
 import type { CanonicalFormatLegacyResolver } from '../../../v2/projection/v2-to-v1';
 /**
  * Lifecycle observability hooks the v6 runtime fires at well-known points.

package/dist/lib/server/decisioning/runtime/from-platform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"from-platform.d.ts","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/runtime/from-platform.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"from-platform.d.ts","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/runtime/from-platform.ts"],"names":[],"mappings":"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"}

package/dist/lib/server/decisioning/runtime/from-platform.js

@@ -57,9 +57,11 @@ var import_observed_modes = require('./observed-modes.js');
 var import_normalize_errors = require('../../normalize-errors.js');
 var import_redact = require('../../redact.js');
 var import_creative_delivery = require('../../../v2/projection/creative-delivery.js');
+var import_v1_to_v2 = require('../../../v2/projection/v1-to-v2.js');
 var import_augment_response = require('../../../v2/projection/augment-response.js');
 var import_v2_to_v1 = require('../../../v2/projection/v2-to-v1.js');
 var import_legacy_metadata = require('../../../v2/projection/legacy-metadata.js');
+var import_resolve_agent_properties = require('../../../discovery/resolve-agent-properties.js');
 var import_version = require('../../../version.js');
 const DEFAULT_FRAMEWORK_LOGGER = {
   debug: () => {
@@ -87,6 +89,21 @@ function requiresCanonicalCreativeWire(version) {
   const minor = Number(match[2]);
   return major > 3 || major === 3 && minor >= 2;
 }
+function supportsTransitionalDualCreativeWire(version) {
+  if (typeof version !== "string") return false;
+  const match = /^v?(\d+)\.(\d+)(?:\.|-|$)/.exec(version.trim());
+  if (!match) return false;
+  return Number(match[1]) === 3 && Number(match[2]) === 1;
+}
+function shouldEmitTransitionalDualCreativeWire(version, request) {
+  if (!supportsTransitionalDualCreativeWire(version)) return false;
+  if (request === null || typeof request !== "object") return true;
+  const fields = Object.getOwnPropertyDescriptor(request, "fields");
+  if (!fields || !("value" in fields) || !Array.isArray(fields.value)) return true;
+  return Object.values(Object.getOwnPropertyDescriptors(fields.value)).some(
+    (descriptor) => descriptor.enumerable && "value" in descriptor && descriptor.value === "format_ids"
+  );
+}
 function creativeWireEvidenceForRequest(request) {
   let canonical = false;
   let legacy = false;
@@ -358,7 +375,7 @@ function asCanonicalSemanticServerResponse(response, operation, legacyFormatConv
 }
 function asSemanticServerResponseForWire(response, operation, legacyFormatConverter, canonicalFormatLegacyResolver, wireMode) {
   if (wireMode === "canonical") {
-    return attachCanonicalCustomFormatWireRefs(
+    return attachCanonicalFormatWireRefs(
       asCanonicalSemanticServerResponse(response, operation, legacyFormatConverter, canonicalFormatLegacyResolver),
       canonicalFormatLegacyResolver,
       operation
@@ -462,10 +479,10 @@ function asCanonicalGetProductsRequest(request) {
   ];
   return { ...request, fields };
 }
-function asCanonicalListCreativesRequest(request, legacyFormatConverter) {
+function asCanonicalListCreativesRequest(request, legacyFormatConverter, responseWireMode) {
   const filters = request["filters"] !== null && typeof request["filters"] === "object" && !Array.isArray(request["filters"]) ? request["filters"] : void 0;
   const legacyFormatIds = filters?.["format_ids"];
-  if (Array.isArray(legacyFormatIds) && legacyFormatIds.length > 0) {
+  if (Array.isArray(legacyFormatIds) && legacyFormatIds.length > 0 && responseWireMode !== "legacy") {
     throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
       message: "list_creatives legacy format_ids filters are unavailable on the canonical platform surface.",
       field: "filters.format_ids",
@@ -480,15 +497,22 @@ function asCanonicalListCreativesRequest(request, legacyFormatConverter) {
     "list_creatives",
     legacyFormatConverter
   );
-  if (!Array.isArray(projected["fields"])) return projected;
+  const withLegacyFilter = responseWireMode === "legacy" && Array.isArray(legacyFormatIds) && legacyFormatIds.length > 0 ? {
+    ...projected,
+    filters: {
+      ...projected["filters"] ?? {},
+      format_ids: legacyFormatIds
+    }
+  } : projected;
+  if (!Array.isArray(withLegacyFilter["fields"])) return withLegacyFilter;
   const fields = [
     ...new Set(
-      projected["fields"].flatMap(
+      withLegacyFilter["fields"].flatMap(
         (field) => field === "format_id" ? ["format_kind"] : typeof field === "string" ? [field] : []
       )
     )
   ];
-  return { ...projected, fields };
+  return { ...withLegacyFilter, fields };
 }
 function asCanonicalProductResponse(response, legacyFormatConverter) {
   try {
@@ -501,41 +525,324 @@ function asCanonicalProductResponse(response, legacyFormatConverter) {
       suggestion: "Return an acyclic data-only product response without enumerable accessors."
     });
   }
+  validateDualProductFormatDeclarations(response, legacyFormatConverter);
   const projected = (0, import_augment_response.toCanonicalOnlyResponse)(response, {
     legacyFormatConverter
   });
-  if (projected.diagnostics.length > 0) {
-    const first = projected.diagnostics[0];
+  const blockingDiagnostics = projected.diagnostics.filter(
+    (diagnostic) => diagnostic.code !== "LEGACY_FORMAT_ID_DROPPED_UNMAPPED"
+  );
+  if (blockingDiagnostics.length > 0) {
+    const first = blockingDiagnostics[0];
     throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
       message: "get_products returned a legacy format that cannot be represented canonically.",
       field: first.field,
       suggestion: "Declare canonical format_options or configure legacyCreativeFormatConverter for the legacy format."
     });
   }
-  return asCanonicalServerResponse(projected.response);
+  const canonicalResponse = asCanonicalServerResponse(projected.response);
+  const resolvedDropDiagnostics = projected.diagnostics.filter(
+    (diagnostic) => diagnostic.code === "LEGACY_FORMAT_ID_DROPPED_UNMAPPED"
+  );
+  if (resolvedDropDiagnostics.length > 0 && canonicalResponse !== null && typeof canonicalResponse === "object") {
+    resolvedLegacyDropDiagnosticsByResponse.set(canonicalResponse, resolvedDropDiagnostics);
+  }
+  preserveAuthoredFormatIds(response, canonicalResponse);
+  return canonicalResponse;
+}
+const authoredFormatIdsByOwner = /* @__PURE__ */ new WeakMap();
+const resolvedLegacyDropDiagnosticsByResponse = /* @__PURE__ */ new WeakMap();
+function ownArrayDataValues(value) {
+  const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+  const length = lengthDescriptor && "value" in lengthDescriptor ? lengthDescriptor.value : 0;
+  if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0) return [];
+  const values = [];
+  for (let index = 0; index < length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (descriptor?.enumerable && "value" in descriptor) values.push(descriptor.value);
+  }
+  return values;
+}
+function cloneWireData(value) {
+  if (Array.isArray(value)) {
+    const cloned2 = [];
+    for (const entry of ownArrayDataValues(value)) cloned2.push(cloneWireData(entry));
+    return cloned2;
+  }
+  if (value === null || typeof value !== "object") return value;
+  const cloned = {};
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (descriptor.enumerable && "value" in descriptor) cloned[key] = cloneWireData(descriptor.value);
+  }
+  return cloned;
+}
+function preserveAuthoredFormatIds(source, target) {
+  if (source === null || target === null || typeof source !== "object" || typeof target !== "object") return;
+  const sourceProducts = Object.getOwnPropertyDescriptor(source, "products");
+  const targetProducts = Object.getOwnPropertyDescriptor(target, "products");
+  if (!sourceProducts || !sourceProducts.enumerable || !("value" in sourceProducts) || !Array.isArray(sourceProducts.value) || !targetProducts || !targetProducts.enumerable || !("value" in targetProducts) || !Array.isArray(targetProducts.value)) {
+    return;
+  }
+  const sourceValues = ownArrayDataValues(sourceProducts.value);
+  const targetValues = ownArrayDataValues(targetProducts.value);
+  const count = Math.min(sourceValues.length, targetValues.length);
+  for (let index = 0; index < count; index++)
+    preserveAuthoredFormatIdsForOwner(sourceValues[index], targetValues[index]);
+}
+function preserveAuthoredFormatIdsForOwner(source, target) {
+  if (source === null || target === null || typeof source !== "object" || typeof target !== "object") return;
+  const sourceProductId = Object.getOwnPropertyDescriptor(source, "product_id");
+  const sourcePlacementId = Object.getOwnPropertyDescriptor(source, "placement_id");
+  const recognizedOwner = sourceProductId?.enumerable && "value" in sourceProductId && typeof sourceProductId.value === "string" || sourcePlacementId?.enumerable && "value" in sourcePlacementId && typeof sourcePlacementId.value === "string";
+  if (!recognizedOwner) return;
+  const sourceFormatIds = Object.getOwnPropertyDescriptor(source, "format_ids");
+  const targetFormatOptions = Object.getOwnPropertyDescriptor(target, "format_options");
+  if (sourceFormatIds && sourceFormatIds.enumerable && "value" in sourceFormatIds && Array.isArray(sourceFormatIds.value) && targetFormatOptions && targetFormatOptions.enumerable && "value" in targetFormatOptions && Array.isArray(targetFormatOptions.value)) {
+    authoredFormatIdsByOwner.set(
+      target,
+      ownArrayDataValues(sourceFormatIds.value).map((ref) => cloneWireData(ref))
+    );
+  }
+  const sourcePlacements = Object.getOwnPropertyDescriptor(source, "placements");
+  const targetPlacements = Object.getOwnPropertyDescriptor(target, "placements");
+  if (sourcePlacements && sourcePlacements.enumerable && "value" in sourcePlacements && Array.isArray(sourcePlacements.value) && targetPlacements && targetPlacements.enumerable && "value" in targetPlacements && Array.isArray(targetPlacements.value)) {
+    const sourceValues = ownArrayDataValues(sourcePlacements.value);
+    const targetValues = ownArrayDataValues(targetPlacements.value);
+    const count = Math.min(sourceValues.length, targetValues.length);
+    for (let index = 0; index < count; index++) {
+      preserveAuthoredFormatIdsForOwner(sourceValues[index], targetValues[index]);
+    }
+  }
 }
-function attachCanonicalCustomFormatWireRefs(value, canonicalFormatLegacyResolver, operation) {
+function removeResolvedLegacyDropErrors(response, diagnostics) {
+  if (response === null || typeof response !== "object") return response;
+  const resolved = diagnostics.filter((diagnostic) => diagnostic.code === "LEGACY_FORMAT_ID_DROPPED_UNMAPPED");
+  if (resolved.length === 0) return response;
+  const record = response;
+  if (!Array.isArray(record.errors)) return response;
+  const retained = [];
+  for (const value of ownArrayDataValues(record.errors)) {
+    let matchesResolvedDiagnostic = false;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const error = value;
+      for (const diagnostic of resolved) {
+        if (error.code === diagnostic.code && error.field === diagnostic.field && error.source === diagnostic.source && error.sdk_id === diagnostic.sdk_id && jsonValuesEqual(error.details, diagnostic.error.details)) {
+          matchesResolvedDiagnostic = true;
+          break;
+        }
+      }
+    }
+    if (!matchesResolvedDiagnostic) retained.push(value);
+  }
+  if (retained.length > 0) return { ...record, errors: retained };
+  const { errors: _resolvedErrors, ...withoutErrors } = record;
+  void _resolvedErrors;
+  return withoutErrors;
+}
+function legacyFormatRefKey(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const ref = value;
+  if (typeof ref.agent_url !== "string" || typeof ref.id !== "string") return void 0;
+  const agentUrl = (0, import_resolve_agent_properties.canonicalizeAgentUrl)(ref.agent_url) ?? ref.agent_url;
+  return `${agentUrl}::${ref.id}::${String(ref.width ?? "")}x${String(ref.height ?? "")}::${String(ref.duration_ms ?? "")}`;
+}
+function jsonValuesEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right)) return false;
+    const leftValues = ownArrayDataValues(left);
+    const rightValues = ownArrayDataValues(right);
+    if (leftValues.length !== rightValues.length) return false;
+    for (let index = 0; index < leftValues.length; index++) {
+      if (!jsonValuesEqual(leftValues[index], rightValues[index])) return false;
+    }
+    return true;
+  }
+  if (left === null || right === null || typeof left !== "object" || typeof right !== "object") return false;
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Object.keys(leftRecord);
+  const rightKeys = Object.keys(rightRecord);
+  return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.hasOwn(rightRecord, key) && jsonValuesEqual(leftRecord[key], rightRecord[key]));
+}
+function matchLegacyRefToDeclaration(declaration, ref, ownerId, legacyFormatConverter) {
+  const projected = (0, import_v1_to_v2.projectV1ProductToV2)(
+    {
+      product_id: ownerId,
+      name: ownerId,
+      description: ownerId,
+      format_ids: [ref]
+    },
+    { legacyFormatConverter }
+  );
+  if (projected.diagnostics.length > 0 || projected.v2.format_options.length !== 1) return "unresolved";
+  const expected = projected.v2.format_options[0];
+  if (declaration.format_kind !== expected.format_kind) return "kind_mismatch";
+  const params = declaration.params !== null && typeof declaration.params === "object" && !Array.isArray(declaration.params) ? declaration.params : {};
+  for (const [key, expectedValue] of Object.entries(expected.params)) {
+    if (!Object.hasOwn(params, key) || !jsonValuesEqual(params[key], expectedValue)) return "params_mismatch";
+  }
+  return "match";
+}
+function validateLegacyRefNarrowing(declaration, ref, ownerId, field, legacyFormatConverter) {
+  const match = matchLegacyRefToDeclaration(declaration, ref, ownerId, legacyFormatConverter);
+  if (match === "kind_mismatch") {
+    throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
+      message: "get_products returned divergent legacy and canonical format declarations.",
+      field,
+      suggestion: "Make format_ids and format_options.v1_format_ref describe the same canonical format."
+    });
+  }
+  if (match === "params_mismatch") {
+    throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
+      message: "get_products returned a canonical declaration that does not narrow its v1_format_ref.",
+      field: `${field}.params`,
+      suggestion: "Align canonical format parameters with the referenced legacy format requirements."
+    });
+  }
+}
+function validateDualProductFormatDeclarations(value, legacyFormatConverter) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const visit = (current, path) => {
+    if (current === null || typeof current !== "object" || seen.has(current)) return;
+    seen.add(current);
+    if (Array.isArray(current)) {
+      const entries = ownArrayDataValues(current);
+      for (let index = 0; index < entries.length; index++) visit(entries[index], `${path}[${index}]`);
+      return;
+    }
+    const record = current;
+    const formatOptions = Array.isArray(record.format_options) ? record.format_options : void 0;
+    const ownerId = typeof record.product_id === "string" ? record.product_id : typeof record.placement_id === "string" ? record.placement_id : void 0;
+    if (formatOptions && ownerId !== void 0) {
+      const declarationRefs = [];
+      const declarations = ownArrayDataValues(formatOptions);
+      for (let index = 0; index < declarations.length; index++) {
+        const value2 = declarations[index];
+        if (value2 === null || typeof value2 !== "object" || Array.isArray(value2)) continue;
+        const declaration = value2;
+        const refs = ownArrayDataValues(
+          (0, import_legacy_metadata.legacyFormatRefsForDeclaration)(declaration)
+        );
+        const field = `${path}.format_options[${index}]`;
+        if (declaration.canonical_formats_only === true && refs.length > 0) {
+          throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
+            message: "get_products returned canonical_formats_only together with v1_format_ref.",
+            field,
+            suggestion: "Remove v1_format_ref or set canonical_formats_only to false."
+          });
+        }
+        declarationRefs.push(...refs);
+        for (const ref of refs) {
+          validateLegacyRefNarrowing(declaration, ref, ownerId, field, legacyFormatConverter);
+        }
+      }
+      if (Array.isArray(record.format_ids)) {
+        const formatIds = ownArrayDataValues(record.format_ids);
+        const formatIdKeys = /* @__PURE__ */ new Set();
+        for (const ref of formatIds) {
+          const key = legacyFormatRefKey(ref);
+          if (key !== void 0) formatIdKeys.add(key);
+        }
+        const declarationRefKeys = /* @__PURE__ */ new Set();
+        for (const ref of declarationRefs) {
+          const key = legacyFormatRefKey(ref);
+          if (key !== void 0) declarationRefKeys.add(key);
+        }
+        let divergent = false;
+        for (const key of declarationRefKeys) {
+          if (!formatIdKeys.has(key)) divergent = true;
+        }
+        for (const ref of formatIds) {
+          const key = legacyFormatRefKey(ref);
+          if (key !== void 0 && declarationRefKeys.has(key)) continue;
+          let matched = false;
+          for (const value2 of declarations) {
+            if (value2 !== null && typeof value2 === "object" && !Array.isArray(value2) && value2.canonical_formats_only !== true && matchLegacyRefToDeclaration(value2, ref, ownerId, legacyFormatConverter) === "match") {
+              matched = true;
+              break;
+            }
+          }
+          if (!matched) divergent = true;
+        }
+        if (divergent) {
+          throw new import_async_outcome.AdcpError("INVALID_REQUEST", {
+            message: "get_products returned divergent format_ids and format_options.v1_format_ref values.",
+            field: path,
+            suggestion: "Dual-emitted product declarations must carry the same legacy format references."
+          });
+        }
+      }
+    }
+    for (const [key, child] of Object.entries(record)) {
+      if (key === "format_options") continue;
+      visit(child, `${path}.${key}`);
+    }
+  };
+  visit(value, "$");
+}
+function attachCanonicalFormatWireRefs(value, canonicalFormatLegacyResolver, operation, emitTransitionalLegacyRefs = false) {
   const visit = (current) => {
-    if (Array.isArray(current)) return current.map(visit);
+    if (Array.isArray(current)) {
+      const mapped = [];
+      for (const entry of ownArrayDataValues(current)) mapped.push(visit(entry));
+      return mapped;
+    }
     if (current === null || typeof current !== "object") return current;
     const record = current;
     const hasFormatDeclarations = Array.isArray(record.format_options);
     const declarationOwner = typeof record.product_id === "string" ? record.product_id : typeof record.placement_id === "string" ? record.placement_id : "(response)";
     let projected = record;
     if (hasFormatDeclarations) {
-      const formatOptions = record.format_options.map((value2, index) => {
-        if (value2 === null || typeof value2 !== "object" || Array.isArray(value2)) return value2;
+      const wireLegacyRefs = [];
+      const wireLegacyRefKeys = /* @__PURE__ */ new Set();
+      const appendWireLegacyRefs = (refs) => {
+        for (const ref of refs) {
+          const key = legacyFormatRefKey(ref);
+          if (key === void 0 || wireLegacyRefKeys.has(key)) continue;
+          wireLegacyRefKeys.add(key);
+          wireLegacyRefs.push(cloneWireData(ref));
+        }
+      };
+      if (emitTransitionalLegacyRefs) {
+        const authoredRefs = authoredFormatIdsByOwner.get(record);
+        if (authoredRefs) appendWireLegacyRefs(authoredRefs);
+      }
+      const formatOptions = [];
+      const declarations = ownArrayDataValues(record.format_options);
+      for (let index = 0; index < declarations.length; index++) {
+        const value2 = declarations[index];
+        if (value2 === null || typeof value2 !== "object" || Array.isArray(value2)) {
+          formatOptions.push(value2);
+          continue;
+        }
         const declaration = value2;
-        if (declaration.format_kind !== "custom" || declaration.canonical_formats_only === true) return declaration;
-        let refs = [...(0, import_legacy_metadata.legacyFormatRefsForDeclaration)(declaration)];
+        if (declaration.canonical_formats_only === true) {
+          formatOptions.push(declaration);
+          continue;
+        }
+        let refs = ownArrayDataValues(
+          (0, import_legacy_metadata.legacyFormatRefsForDeclaration)(declaration)
+        );
+        if (emitTransitionalLegacyRefs && refs.length > 0) {
+          const clonedRefs2 = refs.map((ref) => cloneWireData(ref));
+          appendWireLegacyRefs(clonedRefs2);
+          formatOptions.push({ ...declaration, v1_format_ref: clonedRefs2 });
+          continue;
+        }
+        if (declaration.format_kind !== "custom") {
+          formatOptions.push(declaration);
+          continue;
+        }
         if (refs.length === 0) {
           try {
-            refs = (0, import_v2_to_v1.resolveCanonicalFormatLegacyRefs)(canonicalFormatLegacyResolver, {
+            const resolved = (0, import_v2_to_v1.resolveCanonicalFormatLegacyRefs)(canonicalFormatLegacyResolver, {
               source: "product",
               declaration,
               productId: declarationOwner,
               field: `${declarationOwner}.format_options[${index}]`
-            }) ?? [];
+            });
+            refs = resolved ? ownArrayDataValues(resolved) : [];
           } catch (error) {
             if (!(error instanceof import_v2_to_v1.CanonicalFormatLegacyResolutionError)) throw error;
             throw new import_creative_delivery.CreativeFormatProjectionError(
@@ -552,9 +859,15 @@ function attachCanonicalCustomFormatWireRefs(value, canonicalFormatLegacyResolve
             "custom canonical declaration must set canonical_formats_only or provide an explicit legacy mapping"
           );
         }
-        return { ...declaration, v1_format_ref: refs.map((ref) => ({ ...ref })) };
-      });
-      projected = { ...record, format_options: formatOptions };
+        const clonedRefs = refs.map((ref) => cloneWireData(ref));
+        if (emitTransitionalLegacyRefs) appendWireLegacyRefs(clonedRefs);
+        formatOptions.push({ ...declaration, v1_format_ref: clonedRefs });
+      }
+      projected = {
+        ...record,
+        format_options: formatOptions,
+        ...emitTransitionalLegacyRefs && wireLegacyRefs.length > 0 && { format_ids: wireLegacyRefs }
+      };
     }
     let changed = projected !== record;
     const next = { ...projected };
@@ -570,9 +883,18 @@ function attachCanonicalCustomFormatWireRefs(value, canonicalFormatLegacyResolve
   };
   return visit(value);
 }
-function asProductResponseForWire(canonicalResponse, wireMode, canonicalFormatLegacyResolver) {
+function asProductResponseForWire(canonicalResponse, wireMode, canonicalFormatLegacyResolver, emitTransitionalLegacyRefs = false) {
   if (wireMode === "canonical") {
-    return attachCanonicalCustomFormatWireRefs(canonicalResponse, canonicalFormatLegacyResolver, "get_products");
+    const responseForWire = emitTransitionalLegacyRefs && canonicalResponse !== null && typeof canonicalResponse === "object" ? removeResolvedLegacyDropErrors(
+      canonicalResponse,
+      resolvedLegacyDropDiagnosticsByResponse.get(canonicalResponse) ?? []
+    ) : canonicalResponse;
+    return attachCanonicalFormatWireRefs(
+      responseForWire,
+      canonicalFormatLegacyResolver,
+      "get_products",
+      emitTransitionalLegacyRefs
+    );
   }
   if (!Array.isArray(canonicalResponse.products)) return canonicalResponse;
   const products = canonicalResponse.products.map((product) => {
@@ -2484,7 +2806,8 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
               return asProductResponseForWire(
                 canonicalResult,
                 responseWireMode,
-                canonicalFormatLegacyResolver
+                canonicalFormatLegacyResolver,
+                shouldEmitTransitionalDualCreativeWire(ctx.servedAdcpVersion, params)
               );
             };
             const isHandoff = (0, import_async_outcome2.isTaskHandoff)(result);
@@ -2706,46 +3029,45 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
         );
       }
     },
-    syncCreatives: async (params, ctx) => {
-      const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
-      params = asCanonicalSemanticServerRequest(params, "sync_creatives", legacyFormatConverter);
-      const reqCtx = ctxFor(ctx, params);
-      const creatives = params.creatives ?? [];
-      if (!sales?.syncCreatives) {
-        return (0, import_errors.adcpError)("UNSUPPORTED_FEATURE", {
-          message: "sync_creatives not supported by this sales platform"
-        });
+    ...sales?.syncCreatives && {
+      syncCreatives: async (params, ctx) => {
+        const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
+        params = asCanonicalSemanticServerRequest(params, "sync_creatives", legacyFormatConverter);
+        const reqCtx = ctxFor(ctx, params);
+        const creatives = params.creatives ?? [];
+        return projectSync(
+          async () => {
+            const push = extractPushConfig(params, logger, {
+              allowPrivateWebhookUrls: pushOpts.allowPrivateWebhookUrls
+            });
+            const result = await sales.syncCreatives(creatives, reqCtx);
+            return routeIfHandoff(
+              taskRegistry,
+              {
+                tool: "sync_creatives",
+                accountId: reqCtx.account.id,
+                ownerScope: taskOwnerScopeFor(ctx, reqCtx.account.id),
+                pushNotificationUrl: push.url,
+                pushNotificationToken: push.token,
+                pushNotificationOperationId: push.operationId,
+                emitWebhook: taskWebhookEmit ?? ctx.emitWebhook,
+                autoEmitCompletion: pushOpts.autoEmitCompletionWebhooks,
+                observability,
+                logger
+              },
+              result,
+              (rows) => asSemanticServerResponseForWire(
+                { creatives: rows.map(normalizeRowErrors) },
+                "sync_creatives",
+                legacyFormatConverter,
+                canonicalFormatLegacyResolver,
+                responseWireMode
+              )
+            );
+          },
+          (r) => r
+        );
       }
-      return projectSync(
-        async () => {
-          const push = extractPushConfig(params, logger, { allowPrivateWebhookUrls: pushOpts.allowPrivateWebhookUrls });
-          const result = await sales.syncCreatives(creatives, reqCtx);
-          return routeIfHandoff(
-            taskRegistry,
-            {
-              tool: "sync_creatives",
-              accountId: reqCtx.account.id,
-              ownerScope: taskOwnerScopeFor(ctx, reqCtx.account.id),
-              pushNotificationUrl: push.url,
-              pushNotificationToken: push.token,
-              pushNotificationOperationId: push.operationId,
-              emitWebhook: taskWebhookEmit ?? ctx.emitWebhook,
-              autoEmitCompletion: pushOpts.autoEmitCompletionWebhooks,
-              observability,
-              logger
-            },
-            result,
-            (rows) => asSemanticServerResponseForWire(
-              { creatives: rows.map(normalizeRowErrors) },
-              "sync_creatives",
-              legacyFormatConverter,
-              canonicalFormatLegacyResolver,
-              responseWireMode
-            )
-          );
-        },
-        (r) => r
-      );
     },
     ...sales?.getMediaBuyDelivery && {
       getMediaBuyDelivery: async (params, ctx) => {
@@ -2828,7 +3150,7 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
               "media_buy_id",
               logger
             );
-            const wireResult = responseWireMode === "canonical" ? attachCanonicalCustomFormatWireRefs(canonicalResult, canonicalFormatLegacyResolver, "get_media_buys") : asSemanticServerResponseForWire(
+            const wireResult = responseWireMode === "canonical" ? attachCanonicalFormatWireRefs(canonicalResult, canonicalFormatLegacyResolver, "get_media_buys") : asSemanticServerResponseForWire(
               result,
               "get_media_buys",
               legacyFormatConverter,
@@ -2881,7 +3203,8 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
         const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
         const canonicalParams = asCanonicalListCreativesRequest(
           params,
-          legacyFormatConverter
+          legacyFormatConverter,
+          responseWireMode
         );
         const reqCtx = ctxFor(ctx, canonicalParams);
         return projectSync(
@@ -3014,7 +3337,8 @@ function buildCreativeHandlers(platform, taskRegistry, taskWebhookEmit, observab
         const responseWireMode = creativeWireModeForRequest(ctx, creativeWireMode, params);
         const canonicalParams = asCanonicalListCreativesRequest(
           params,
-          legacyFormatConverter
+          legacyFormatConverter,
+          responseWireMode
         );
         const reqCtx = ctxFor(ctx, canonicalParams);
         return projectSync(