@adcp/sdk 16.3.0 → 16.4.0

package/dist/lib/core/buyer-account-registry.mjs

@@ -22,6 +22,10 @@ function isDefinitiveRejection(result) {
     result.adcpError && !result.adcpError.synthetic && !result.adcpError.code.startsWith("IDEMPOTENCY_") && ["terminal", "correctable"].includes(result.adcpError.recovery ?? "")
   );
 }
+function rowMatchesReference(ref, row) {
+  if ("account_id" in ref) return row.account_id === ref.account_id;
+  return row.brand?.domain === ref.brand.domain && row.operator === ref.operator && (!ref.brand.brand_id || row.brand.brand_id === ref.brand.brand_id) && sameCountrySet(ref.brand.countries, row.brand.countries) && (!ref.operator_unit || row.operator_unit?.id === ref.operator_unit.id) && (!ref.currency || row.currency === ref.currency) && (!ref.timezone || row.timezone === ref.timezone) && (row.sandbox === void 0 || row.sandbox === true === (ref.sandbox === true));
+}
 class BuyerAccountRegistry {
   constructor(scope, provision, storage, repair, registryOptions = {}) {
     this.scope = scope;
@@ -40,6 +44,8 @@ class BuyerAccountRegistry {
   repair;
   registryOptions;
   entries = /* @__PURE__ */ new Map();
+  /** Reduction bindings when no storage is configured (never evicted). */
+  reductions = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
   writes = Promise.resolve();
   repairs = /* @__PURE__ */ new Map();
@@ -421,12 +427,13 @@ class BuyerAccountRegistry {
     return this.enqueue(async () => {
       if (scope !== this.scope()) return;
       for (const ref of refs) {
-        const candidates = rows.filter((value) => {
-          if (!value || typeof value !== "object") return false;
-          const row2 = value;
-          if ("account_id" in ref) return row2.account_id === ref.account_id;
-          return row2.brand?.domain === ref.brand.domain && row2.operator === ref.operator && (!ref.brand.brand_id || row2.brand.brand_id === ref.brand.brand_id) && sameCountrySet(ref.brand.countries, row2.brand.countries) && (!ref.operator_unit || row2.operator_unit?.id === ref.operator_unit.id) && (!ref.currency || row2.currency === ref.currency) && (!ref.timezone || row2.timezone === ref.timezone) && (row2.sandbox === void 0 || row2.sandbox === true === (ref.sandbox === true));
-        });
+        const isRow = (value) => !!value && typeof value === "object";
+        let candidates = rows.filter((value) => isRow(value) && rowMatchesReference(ref, value));
+        if (candidates.length === 0 && !("account_id" in ref)) {
+          const reduction = (await this.reductionFor(ref))?.account;
+          if (scope !== this.scope()) return;
+          if (reduction) candidates = rows.filter((value) => isRow(value) && rowMatchesReference(reduction, value));
+        }
         if (candidates.length !== 1) continue;
         let row = candidates[0];
         if (row.action === "failed" || typeof row.status !== "string") continue;
@@ -591,6 +598,135 @@ class BuyerAccountRegistry {
       }
     }
   }
+  reductionKey(kind, account, scope = this.scope()) {
+    return `${scope}:${kind}:${accountReferenceKey(account)}`;
+  }
+  async readReduction(key) {
+    const entry = this.storage ? await this.storage.get(key) : this.reductions.get(key);
+    return entry && entry.status === "reduced" ? structuredClone(entry) : void 0;
+  }
+  /** Insert-if-absent; returns false when another writer already holds the key. */
+  async insertReduction(key, entry) {
+    const prior = this.storage ? await this.storage.get(key) : this.reductions.get(key);
+    if (prior && prior.status === "reduced") return false;
+    if (this.storage?.compareAndSet) {
+      return this.storage.compareAndSet(key, prior?.revision, { ...entry, revision: (prior?.revision ?? 0) + 1 });
+    }
+    if (this.storage) await this.storage.set(key, structuredClone(entry));
+    else this.reductions.set(key, structuredClone(entry));
+    return true;
+  }
+  async replaceReduction(key, entry) {
+    const prior = this.storage ? await this.storage.get(key) : this.reductions.get(key);
+    if (this.storage?.compareAndSet) {
+      const next = { ...entry, revision: (prior?.revision ?? 0) + 1 };
+      if (!await this.storage.compareAndSet(key, prior?.revision, next))
+        throw new AccountSetupRequiredError("Account storage revision changed. Reload and reconcile before retrying.");
+    } else if (this.storage) await this.storage.set(key, structuredClone(entry));
+    else this.reductions.set(key, structuredClone(entry));
+  }
+  /**
+   * Bind reduced account keys to the buyer keys they came from, before a
+   * request carrying them is sent to a seller on an older release. Each
+   * reduced key serves one buyer key only. A key sent unreduced claims itself
+   * (`account` and `reduced` equal), so a plain key and a reduced one can never
+   * land on the same seller account in either order.
+   *
+   * All-or-nothing: every claim is checked, against storage and against the
+   * other claims in the same request, before any is written. On a conflict
+   * nothing is written and the index and owner of the first conflicting claim
+   * are returned. A claim lost to a concurrent writer rolls back the claims
+   * this call already wrote.
+   */
+  async claimReductions(claims) {
+    const scope = this.scope();
+    let conflict;
+    await this.enqueue(async () => {
+      const pending = /* @__PURE__ */ new Map();
+      const toInsert = [];
+      for (const [index, claim] of claims.entries()) {
+        const reducedKey = accountReferenceKey(claim.reduced);
+        const inRequest = pending.get(reducedKey);
+        if (inRequest && accountReferenceKey(inRequest) !== accountReferenceKey(claim.account)) {
+          conflict = { index, owner: inRequest };
+          return;
+        }
+        pending.set(reducedKey, claim.account);
+        const owner = (await this.readReduction(this.reductionKey("reduced", claim.reduced, scope)))?.reducedFrom;
+        if (owner && accountReferenceKey(owner) !== accountReferenceKey(claim.account)) {
+          conflict = { index, owner };
+          return;
+        }
+        if (!owner && !inRequest) toInsert.push(index);
+      }
+      const inserted = [];
+      for (const index of toInsert) {
+        const claim = claims[index];
+        const reverseKey = this.reductionKey("reduced", claim.reduced, scope);
+        const ok = await this.insertReduction(reverseKey, {
+          account: structuredClone(claim.reduced),
+          status: "reduced",
+          reducedFrom: structuredClone(claim.account)
+        });
+        const winner = ok ? void 0 : (await this.readReduction(reverseKey))?.reducedFrom;
+        if (!ok && winner && accountReferenceKey(winner) !== accountReferenceKey(claim.account)) {
+          for (const done of inserted) {
+            const doneClaim = claims[done];
+            await this.replaceReduction(this.reductionKey("reduced", doneClaim.reduced, scope), {
+              account: structuredClone(doneClaim.reduced),
+              status: "released"
+            });
+          }
+          conflict = { index, owner: winner };
+          return;
+        }
+        if (ok) inserted.push(index);
+      }
+      for (const claim of claims) {
+        if (accountReferenceKey(claim.account) === accountReferenceKey(claim.reduced)) continue;
+        const forwardKey = this.reductionKey("reduction", claim.account, scope);
+        const current = await this.readReduction(forwardKey);
+        const reduction = { account: claim.reduced, adcpVersion: claim.adcpVersion };
+        if (current?.reduction && isDeepStrictEqual(current.reduction, reduction)) continue;
+        await this.replaceReduction(forwardKey, {
+          account: structuredClone(claim.account),
+          status: "reduced",
+          reduction: structuredClone(reduction)
+        });
+      }
+    });
+    return conflict;
+  }
+  /** The buyer key a reduced seller key was claimed for, if any. */
+  async reductionOwner(reduced) {
+    return (await this.readReduction(this.reductionKey("reduced", reduced)))?.reducedFrom;
+  }
+  /** The reduced key a buyer key reached an older seller with, if any. */
+  async reductionFor(account) {
+    return (await this.readReduction(this.reductionKey("reduction", account)))?.reduction;
+  }
+  /**
+   * Forget that `account` reached this seller under a reduced key. Call once
+   * the account has moved to its full key: after a `sync_accounts` settings
+   * update rekeys `operator_unit` in place, or after opening a new account
+   * under the full key when the reduced fields (`currency`, `timezone`,
+   * `brand.countries`) cannot change on an existing account. Until then the
+   * client keeps addressing the seller account by its reduced key.
+   */
+  async clearReduction(account) {
+    const scope = this.scope();
+    await this.enqueue(async () => {
+      const forwardKey = this.reductionKey("reduction", account, scope);
+      const forward = await this.readReduction(forwardKey);
+      if (!forward?.reduction) return;
+      const reverseKey = this.reductionKey("reduced", forward.reduction.account, scope);
+      const reverse = await this.readReduction(reverseKey);
+      if (reverse?.reducedFrom && accountReferenceKey(reverse.reducedFrom) === accountReferenceKey(account)) {
+        await this.replaceReduction(reverseKey, { account: reverse.account, status: "released" });
+      }
+      await this.replaceReduction(forwardKey, { account: forward.account, status: "released" });
+    });
+  }
 }
 export {
   BuyerAccountRegistry

package/dist/lib/media-buy/action-contracts.js

@@ -45,6 +45,7 @@ var import_media_buy_helpers = require('../server/media-buy-helpers.js');
 var import_available_actions = require('./available-actions.js');
 const NON_TERMINAL_ACTION_STATUSES = ["pending_creatives", "pending_start", "active", "paused"];
 const MODES = ["self_serve", "conditional_self_serve", "seller_managed", "requires_approval"];
+const CANONICAL_TASKS = new Set(Object.values(import_action_metadata.CANONICAL_ACTION_TASKS).flat());
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const finite = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
 function mediaBuyActionTasks(action) {
@@ -137,7 +138,7 @@ function changeConstraintIssues(action, constraints, currency) {
 }
 function slaValid(sla) {
   return sla === void 0 || record(sla) && Object.entries(sla).every(
-    ([k, v]) => ["response_max", "completion_max"].includes(k) && typeof v === "string" && /^P(?!$)(\d+Y)?(\d+M)?(\d+D)?(T(\d+H)?(\d+M)?(\d+S)?)?$/.test(v)
+    ([k, v]) => k === "clock" && v === "elapsed" || ["response_max", "completion_max"].includes(k) && typeof v === "string" && /^P(?!$)(\d+Y)?(\d+M)?(\d+D)?(T(\d+H)?(\d+M)?(\d+S)?)?$/.test(v)
   );
 }
 function changeTermIssues(terms, currency) {
@@ -211,7 +212,7 @@ function productTemplateIssues(templates, currency) {
         currency
       ).filter((issue) => issue !== "invalid or duplicate action identity")
     );
-    if (![...import_action_metadata.CHANGE_TERM_ACTIONS, ...import_action_metadata.LEGACY_AVAILABLE_ACTIONS].includes(template.action))
+    if (!Object.hasOwn(import_action_metadata.CANONICAL_ACTION_TASKS, template.action) && !import_action_metadata.LEGACY_AVAILABLE_ACTIONS.includes(template.action))
       issues.push("invalid product action");
     if (template.allowed_statuses !== void 0 && (!Array.isArray(template.allowed_statuses) || !template.allowed_statuses.length || new Set(template.allowed_statuses).size !== template.allowed_statuses.length || template.allowed_statuses.some(
       (status) => ![...NON_TERMINAL_ACTION_STATUSES, "completed", "rejected", "canceled"].includes(status)
@@ -233,8 +234,7 @@ function liveActionIssues(entries) {
     if (!record(entry) || typeof entry.action !== "string" || !entry.action || typeof entry.mode !== "string" || !entry.mode || seen.has(entry.action))
       return ["invalid or duplicate live action"];
     seen.add(entry.action);
-    if (entry.task !== void 0 && !["control_media_buy", "refine_proposals", "sync_creatives"].includes(String(entry.task)))
-      return ["invalid live task"];
+    if (entry.task !== void 0 && !CANONICAL_TASKS.has(String(entry.task))) return ["invalid live task"];
     if (!slaValid(entry.sla)) return ["invalid live SLA"];
     if (entry.change_term_id !== void 0 && (typeof entry.change_term_id !== "string" || !/^[A-Za-z0-9_.:-]+$/.test(entry.change_term_id)))
       return ["invalid live term identity"];

package/dist/lib/media-buy/action-contracts.mjs

@@ -9,6 +9,7 @@ import { validActionsForStatus } from "../server/media-buy-helpers.mjs";
 import { getRollupParent } from "./available-actions.mjs";
 const NON_TERMINAL_ACTION_STATUSES = ["pending_creatives", "pending_start", "active", "paused"];
 const MODES = ["self_serve", "conditional_self_serve", "seller_managed", "requires_approval"];
+const CANONICAL_TASKS = new Set(Object.values(CANONICAL_ACTION_TASKS).flat());
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const finite = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
 function mediaBuyActionTasks(action) {
@@ -101,7 +102,7 @@ function changeConstraintIssues(action, constraints, currency) {
 }
 function slaValid(sla) {
   return sla === void 0 || record(sla) && Object.entries(sla).every(
-    ([k, v]) => ["response_max", "completion_max"].includes(k) && typeof v === "string" && /^P(?!$)(\d+Y)?(\d+M)?(\d+D)?(T(\d+H)?(\d+M)?(\d+S)?)?$/.test(v)
+    ([k, v]) => k === "clock" && v === "elapsed" || ["response_max", "completion_max"].includes(k) && typeof v === "string" && /^P(?!$)(\d+Y)?(\d+M)?(\d+D)?(T(\d+H)?(\d+M)?(\d+S)?)?$/.test(v)
   );
 }
 function changeTermIssues(terms, currency) {
@@ -175,7 +176,7 @@ function productTemplateIssues(templates, currency) {
         currency
       ).filter((issue) => issue !== "invalid or duplicate action identity")
     );
-    if (![...CHANGE_TERM_ACTIONS, ...LEGACY_AVAILABLE_ACTIONS].includes(template.action))
+    if (!Object.hasOwn(CANONICAL_ACTION_TASKS, template.action) && !LEGACY_AVAILABLE_ACTIONS.includes(template.action))
       issues.push("invalid product action");
     if (template.allowed_statuses !== void 0 && (!Array.isArray(template.allowed_statuses) || !template.allowed_statuses.length || new Set(template.allowed_statuses).size !== template.allowed_statuses.length || template.allowed_statuses.some(
       (status) => ![...NON_TERMINAL_ACTION_STATUSES, "completed", "rejected", "canceled"].includes(status)
@@ -197,8 +198,7 @@ function liveActionIssues(entries) {
     if (!record(entry) || typeof entry.action !== "string" || !entry.action || typeof entry.mode !== "string" || !entry.mode || seen.has(entry.action))
       return ["invalid or duplicate live action"];
     seen.add(entry.action);
-    if (entry.task !== void 0 && !["control_media_buy", "refine_proposals", "sync_creatives"].includes(String(entry.task)))
-      return ["invalid live task"];
+    if (entry.task !== void 0 && !CANONICAL_TASKS.has(String(entry.task))) return ["invalid live task"];
     if (!slaValid(entry.sla)) return ["invalid live SLA"];
     if (entry.change_term_id !== void 0 && (typeof entry.change_term_id !== "string" || !/^[A-Za-z0-9_.:-]+$/.test(entry.change_term_id)))
       return ["invalid live term identity"];

package/dist/lib/media-buy/action-types.d.mts

@@ -1,7 +1,8 @@
 import type { CanonicalProductAction, MediaBuyChangeTerm, MediaBuyChangeTermConstraints, MediaBuyStatus } from '../types/core.generated.mjs';
 import type { MediaBuyActionContext, MediaBuyActionId, MediaBuyActionMode, SLAWindow } from './types.mjs';
-/** Explicit task vocabulary; update_media_buy is the established 3.1 default. */
-export type MediaBuyTask = 'update_media_buy' | 'control_media_buy' | 'refine_proposals' | 'sync_creatives';
+import type { CANONICAL_ACTION_TASKS } from './action-metadata.generated.mjs';
+/** Canonical wire tasks plus the established 3.1 mutation facade. */
+export type MediaBuyTask = 'update_media_buy' | (typeof CANONICAL_ACTION_TASKS)[keyof typeof CANONICAL_ACTION_TASKS][number];
 /** Alias of the shared, schema-derived action vocabulary. */
 export type MediaBuyAction = MediaBuyActionId;
 export type ProductActionTemplate = Pick<CanonicalProductAction, 'modes' | 'allowed_statuses' | 'sla' | 'constraints' | 'terms_ref'> & {

package/dist/lib/media-buy/action-types.d.ts

@@ -1,7 +1,8 @@
 import type { CanonicalProductAction, MediaBuyChangeTerm, MediaBuyChangeTermConstraints, MediaBuyStatus } from '../types/core.generated';
 import type { MediaBuyActionContext, MediaBuyActionId, MediaBuyActionMode, SLAWindow } from './types';
-/** Explicit task vocabulary; update_media_buy is the established 3.1 default. */
-export type MediaBuyTask = 'update_media_buy' | 'control_media_buy' | 'refine_proposals' | 'sync_creatives';
+import type { CANONICAL_ACTION_TASKS } from './action-metadata.generated';
+/** Canonical wire tasks plus the established 3.1 mutation facade. */
+export type MediaBuyTask = 'update_media_buy' | (typeof CANONICAL_ACTION_TASKS)[keyof typeof CANONICAL_ACTION_TASKS][number];
 /** Alias of the shared, schema-derived action vocabulary. */
 export type MediaBuyAction = MediaBuyActionId;
 export type ProductActionTemplate = Pick<CanonicalProductAction, 'modes' | 'allowed_statuses' | 'sla' | 'constraints' | 'terms_ref'> & {

package/dist/lib/media-buy/update-fields.generated.d.mts

@@ -1,8 +1,9 @@
 import type { MediaBuyValidAction } from './types.mjs';
 /**
- * Actions that exist only on the structured `available_actions[].action`
- * surface (absent from the deprecated flat `valid_actions[]` enum). Their
+ * Update-binding actions that exist only on `available_actions[].action`
+ * (absent from the deprecated flat `valid_actions[]` enum). Their
  * field bindings come from `core/media-buy-available-action-id.json`.
+ * Actions routed exclusively to other tasks are excluded.
  * Empty when the schema cache predates that file.
  */
 export declare const STRUCTURED_ONLY_MEDIA_BUY_ACTIONS: readonly ["update_media_buy_frequency_cap"];

package/dist/lib/media-buy/update-fields.generated.d.ts

@@ -1,8 +1,9 @@
 import type { MediaBuyValidAction } from './types';
 /**
- * Actions that exist only on the structured `available_actions[].action`
- * surface (absent from the deprecated flat `valid_actions[]` enum). Their
+ * Update-binding actions that exist only on `available_actions[].action`
+ * (absent from the deprecated flat `valid_actions[]` enum). Their
  * field bindings come from `core/media-buy-available-action-id.json`.
+ * Actions routed exclusively to other tasks are excluded.
  * Empty when the schema cache predates that file.
  */
 export declare const STRUCTURED_ONLY_MEDIA_BUY_ACTIONS: readonly ["update_media_buy_frequency_cap"];

package/dist/lib/registry/types.generated.d.mts

@@ -3612,7 +3612,7 @@ export interface components {
                     } | {
                         /** @enum {string} */
                         kind: "targeting_restriction";
-                        restricted_attributes?: ("racial_ethnic_origin" | "political_opinions" | "religious_beliefs" | "trade_union_membership" | "health_data" | "sex_life_sexual_orientation" | "genetic_data" | "biometric_data" | "age" | "familial_status")[];
+                        restricted_attributes?: ("racial_ethnic_origin" | "political_opinions" | "religious_beliefs" | "trade_union_membership" | "health_data" | "sex_life_sexual_orientation" | "genetic_data" | "biometric_data" | "age" | "familial_status" | "sex_gender")[];
                         description?: string;
                     } | {
                         /** @enum {string} */

package/dist/lib/registry/types.generated.d.ts

@@ -3612,7 +3612,7 @@ export interface components {
                     } | {
                         /** @enum {string} */
                         kind: "targeting_restriction";
-                        restricted_attributes?: ("racial_ethnic_origin" | "political_opinions" | "religious_beliefs" | "trade_union_membership" | "health_data" | "sex_life_sexual_orientation" | "genetic_data" | "biometric_data" | "age" | "familial_status")[];
+                        restricted_attributes?: ("racial_ethnic_origin" | "political_opinions" | "religious_beliefs" | "trade_union_membership" | "health_data" | "sex_life_sexual_orientation" | "genetic_data" | "biometric_data" | "age" | "familial_status" | "sex_gender")[];
                         description?: string;
                     } | {
                         /** @enum {string} */

package/dist/lib/server/create-adcp-server.d.mts

@@ -1,3 +1,4 @@
+import { type VersionDrift } from '../adapters/version/index.mjs';
 /**
  * Declarative AdCP server builder.
  *
@@ -1198,6 +1199,17 @@ export type WebhooksConfig = Pick<WebhookEmitterOptions, 'signerKey' | 'signerPr
     /** Observability: receives failures isolated from attempt observers. */
     onAttemptObserverError?: WebhookEmitterOptions['onAttemptObserverError'];
 };
+/** One request or response conversion between the server's release and a buyer's. */
+export interface AdcpVersionTranslationEvent {
+    tool: string;
+    direction: 'request' | 'response';
+    /** Release the payload was converted from. */
+    fromVersion: string;
+    /** Release the payload was converted to. */
+    toVersion: string;
+    /** What each conversion step removed or moved. */
+    drifts: VersionDrift[];
+}
 export interface AdcpServerConfig<TAccount = unknown> {
     /** Experimental 3.3 authorization, invoked before idempotency and handler side effects. */
     identity33?: {
@@ -1258,6 +1270,15 @@ export interface AdcpServerConfig<TAccount = unknown> {
      * releases, and no newer than `adcpVersion`.
      */
     defaultAdcpVersion?: AdcpVersion | (string & {});
+    /**
+     * Called each time the framework converts a request up from, or a
+     * handler's response down to, a buyer's older release. `drifts` lists every
+     * field the conversion removed or moved, with JSON paths, so a seller can
+     * record what an older buyer did not receive. The same events are logged
+     * at `debug` (requests) and `info` (responses). A throwing callback is
+     * logged and ignored.
+     */
+    onVersionTranslation?: (event: AdcpVersionTranslationEvent) => void;
     /**
      * Per-tool inclusive protocol-release availability. This narrows, but does
      * not replace, the server-wide releases declared through capabilities.

package/dist/lib/server/create-adcp-server.d.ts

@@ -1,3 +1,4 @@
+import { type VersionDrift } from '../adapters/version';
 /**
  * Declarative AdCP server builder.
  *
@@ -1198,6 +1199,17 @@ export type WebhooksConfig = Pick<WebhookEmitterOptions, 'signerKey' | 'signerPr
     /** Observability: receives failures isolated from attempt observers. */
     onAttemptObserverError?: WebhookEmitterOptions['onAttemptObserverError'];
 };
+/** One request or response conversion between the server's release and a buyer's. */
+export interface AdcpVersionTranslationEvent {
+    tool: string;
+    direction: 'request' | 'response';
+    /** Release the payload was converted from. */
+    fromVersion: string;
+    /** Release the payload was converted to. */
+    toVersion: string;
+    /** What each conversion step removed or moved. */
+    drifts: VersionDrift[];
+}
 export interface AdcpServerConfig<TAccount = unknown> {
     /** Experimental 3.3 authorization, invoked before idempotency and handler side effects. */
     identity33?: {
@@ -1258,6 +1270,15 @@ export interface AdcpServerConfig<TAccount = unknown> {
      * releases, and no newer than `adcpVersion`.
      */
     defaultAdcpVersion?: AdcpVersion | (string & {});
+    /**
+     * Called each time the framework converts a request up from, or a
+     * handler's response down to, a buyer's older release. `drifts` lists every
+     * field the conversion removed or moved, with JSON paths, so a seller can
+     * record what an older buyer did not receive. The same events are logged
+     * at `debug` (requests) and `info` (responses). A throwing callback is
+     * logged and ignored.
+     */
+    onVersionTranslation?: (event: AdcpVersionTranslationEvent) => void;
     /**
      * Per-tool inclusive protocol-release availability. This narrows, but does
      * not replace, the server-wide releases declared through capabilities.

package/dist/lib/server/create-adcp-server.js

@@ -31,6 +31,7 @@ __export(create_adcp_server_exports, {
 });
 module.exports = __toCommonJS(create_adcp_server_exports);
 var import_web_bot_auth = require('../signing/web-bot-auth.js');
+var import_version = require('../adapters/version/index.js');
 var import_schema_loader = require('../validation/schema-loader.js');
 var import_lifecycle = require('../identity-3.3/lifecycle.js');
 var import_server = require('../identity-3.3/server.js');
@@ -38,7 +39,7 @@ var import_web_bot_auth2 = require('../signing/web-bot-auth.js');
 var import_validation = require('../identity-3.3/validation.js');
 var import_trust = require('../identity-3.3/trust.js');
 var import_zod = require("zod");
-var import_version = require('../version.js');
+var import_version2 = require('../version.js');
 var import_adcp_version_config = require('../utils/adcp-version-config.js');
 var import_errors = require('../errors/index.js');
 var import_schema_loader2 = require('../validation/schema-loader.js');
@@ -79,7 +80,7 @@ var import_middleware = require('../signing/middleware.js');
 var import_operation_resolution = require('../signing/operation-resolution.js');
 var import_account_mode = require('./account-mode.js');
 var import_test_controller_bridge = require('./test-controller-bridge.js');
-var import_version2 = require('../version.js');
+var import_version3 = require('../version.js');
 var import_schemas2 = require('../types/schemas.generated.js');
 var import_error_codes = require('../types/error-codes.js');
 function hasIdempotencyClearAll(store) {
@@ -1406,7 +1407,7 @@ function normalizeMediaBuyStatusCollision(response, toolName) {
 }
 function injectVersionIntoResponse(response, servedVersion) {
   if (!servedVersion) return;
-  const wireVersion = (0, import_version.toReleasePrecisionVersion)(servedVersion);
+  const wireVersion = (0, import_version2.toReleasePrecisionVersion)(servedVersion);
   const sc = response.structuredContent;
   if (sc && typeof sc === "object" && !("adcp_version" in sc)) {
     const mirrorsStructuredContent = contentTextMirrorsStructuredContent(response, sc);
@@ -1660,11 +1661,11 @@ function getAdvertisedSupportedMajors(capConfig, serverPin) {
     if (Number.isFinite(m)) out.add(m);
   }
   for (const v of capConfig?.supported_versions ?? []) {
-    const m = (0, import_version.parseAdcpMajorVersion)(v);
+    const m = (0, import_version2.parseAdcpMajorVersion)(v);
     if (Number.isFinite(m)) out.add(m);
   }
   if (out.size === 0) {
-    const pinMajor = (0, import_version.parseAdcpMajorVersion)(serverPin);
+    const pinMajor = (0, import_version2.parseAdcpMajorVersion)(serverPin);
     if (Number.isFinite(pinMajor)) out.add(pinMajor);
   }
   return out;
@@ -1676,7 +1677,7 @@ function buildSupportedVersionsList(capConfig, serverPin) {
   if (capConfig?.major_versions?.length) {
     return capConfig.major_versions.filter((m) => Number.isFinite(m)).map((m) => String(m));
   }
-  const pinMajor = (0, import_version.parseAdcpMajorVersion)(serverPin);
+  const pinMajor = (0, import_version2.parseAdcpMajorVersion)(serverPin);
   return Number.isFinite(pinMajor) ? [String(pinMajor)] : [];
 }
 function withImmutableServedAdcpVersion(context, servedAdcpVersion) {
@@ -1695,7 +1696,7 @@ function parseAdcpRelease(value) {
   if (typeof value !== "string") return void 0;
   let wire;
   try {
-    wire = (0, import_version.toReleasePrecisionVersion)(value);
+    wire = (0, import_version2.toReleasePrecisionVersion)(value);
   } catch {
     return void 0;
   }
@@ -1842,7 +1843,7 @@ let bundledCompatibleReleases;
 function bundledReleasesForMajors(majors, configured) {
   const acceptedMajors = new Set(majors);
   const releases = /* @__PURE__ */ new Map();
-  bundledCompatibleReleases ??= import_version.COMPATIBLE_ADCP_VERSIONS.flatMap((version) => {
+  bundledCompatibleReleases ??= import_version2.COMPATIBLE_ADCP_VERSIONS.flatMap((version) => {
     if (!(0, import_schema_loader2.hasSchemaBundle)(version)) return [];
     const parsed = parseAdcpRelease(version);
     return parsed ? [parsed] : [];
@@ -1993,7 +1994,7 @@ function createAdcpServer(config) {
     responseEnhancer,
     structuredContentTextFallback = "always"
   } = config;
-  if (capConfig?.major_versions?.some((major) => major < 3) || capConfig?.supported_versions?.some((version2) => (0, import_version.parseAdcpMajorVersion)(version2) < 3)) {
+  if (capConfig?.major_versions?.some((major) => major < 3) || capConfig?.supported_versions?.some((version2) => (0, import_version2.parseAdcpMajorVersion)(version2) < 3)) {
     throw new import_errors.ConfigurationError(
       "AdCP 2 reached end of life on 2026-08-01. Server capabilities must advertise AdCP 3 only.",
       "capabilities"
@@ -2058,14 +2059,14 @@ function createAdcpServer(config) {
   }
   const credentialPolicyPatterns = credentialPolicy === void 0 || typeof credentialPolicy === "string" ? void 0 : credentialPolicy.patterns;
   const adcpVersion = (0, import_adcp_version_config.resolveAdcpVersion)(
-    configuredAdcpVersion ?? (config.identity33 ? "3.3" : config.proposalNegotiation ? import_version2.ADCP_VERSION : void 0)
+    configuredAdcpVersion ?? (config.identity33 ? "3.3" : config.proposalNegotiation ? import_version3.ADCP_VERSION : void 0)
   );
   const toolVersionRanges = parseToolVersionRanges(config.toolVersions);
   const toolAvailableForRelease = (toolName, release) => toolIsAvailableInRelease(toolVersionRanges, toolName, release);
   const movingSupportedVersion = capConfig?.supported_versions?.find(import_adcp_version_config.isMovingAdcpPrereleaseFamilyAlias);
   if (movingSupportedVersion) {
     throw new Error(
-      `createAdcpServer: capabilities.supported_versions contains moving prerelease-family alias ${JSON.stringify(movingSupportedVersion)}; pin ${JSON.stringify((0, import_version.toReleasePrecisionVersion)(import_version2.ADCP_VERSION))} instead`
+      `createAdcpServer: capabilities.supported_versions contains moving prerelease-family alias ${JSON.stringify(movingSupportedVersion)}; pin ${JSON.stringify((0, import_version2.toReleasePrecisionVersion)(import_version3.ADCP_VERSION))} instead`
     );
   }
   const configuredDefaultVersion = configuredDefaultAdcpVersion === void 0 ? void 0 : (0, import_adcp_version_config.resolveAdcpVersion)(configuredDefaultAdcpVersion, "defaultAdcpVersion");
@@ -2351,6 +2352,43 @@ function createAdcpServer(config) {
     const selected = selectServedAdcpRelease(params, capConfig, adcpVersion, defaultAdcpVersion);
     return isMcpToolResponse(selected) ? void 0 : selected;
   };
+  const downgradeTaskStatusResult = (toolName, response, servedVersion) => {
+    if (toolName !== "get_task_status" || config.identity33) return response;
+    if ((0, import_version.translationSteps)(adcpVersion, servedVersion).length === 0) return response;
+    const body = response.structuredContent;
+    if (!body || typeof body.task_type !== "string" || !body.result || typeof body.result !== "object") return response;
+    const downgraded = (0, import_version.downgradeResponse)(body.task_type, body.result, {
+      fromVersion: adcpVersion,
+      toVersion: servedVersion
+    });
+    if (downgraded.drifts.length > 0) {
+      reportVersionTranslation({
+        tool: body.task_type,
+        direction: "response",
+        fromVersion: adcpVersion,
+        toVersion: servedVersion,
+        drifts: downgraded.drifts
+      });
+    }
+    if (downgraded.data === body.result) return response;
+    const mirrors = contentTextMirrorsStructuredContent(response, body);
+    const next = cloneFormattedResponse(response);
+    const nextBody = { ...next.structuredContent, result: downgraded.data };
+    next.structuredContent = nextBody;
+    syncContentJsonText(next, nextBody, mirrors);
+    return next;
+  };
+  const reportVersionTranslation = (event) => {
+    if (!config.onVersionTranslation) return;
+    try {
+      config.onVersionTranslation(event);
+    } catch (err) {
+      logger.warn("onVersionTranslation callback threw", {
+        tool: event.tool,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  };
   const releaseDefinesTool = (toolName, release) => {
     if (toolName === "refine_proposals") return true;
     try {
@@ -2367,6 +2405,7 @@ function createAdcpServer(config) {
     sanitizeAdcpErrorEnvelope(response);
     enrichErrorTwoLayer(response, toolName, (0, import_error_arm_tools.getToolsWithErrorArm)(release.validationVersion));
     if (!isErrorResponse(response)) {
+      response = downgradeTaskStatusResult(toolName, response, release.validationVersion);
       normalizeMediaBuyStatusCollision(response, toolName);
       injectEnvelopeStatusIntoResponse(response, toolName);
       const validationError = protocolTaskResponseValidationError(toolName, response, params);
@@ -2726,6 +2765,7 @@ function createAdcpServer(config) {
           requestRelease = releaseSelection;
         }
         const requestErrorArms = (0, import_error_arm_tools.getToolsWithErrorArm)(requestRelease.validationVersion);
+        const translatesRelease = !config.identity33 && toolName !== "get_adcp_capabilities" && (0, import_version.translationSteps)(adcpVersion, requestRelease.validationVersion).length > 0;
         const ctx = withImmutableServedAdcpVersion(
           {
             store: stateStore,
@@ -2868,7 +2908,7 @@ function createAdcpServer(config) {
         const reqAdcpMajorRaw = params.adcp_major_version;
         const reqAdcpMajor = typeof reqAdcpMajorRaw === "number" ? reqAdcpMajorRaw : typeof reqAdcpMajorRaw === "string" ? Number.parseInt(reqAdcpMajorRaw, 10) : void 0;
         if (typeof reqAdcpVersion === "string" && reqAdcpMajor !== void 0 && Number.isFinite(reqAdcpMajor)) {
-          const stringMajor = (0, import_version.parseAdcpMajorVersion)(reqAdcpVersion);
+          const stringMajor = (0, import_version2.parseAdcpMajorVersion)(reqAdcpVersion);
           if (Number.isFinite(stringMajor) && stringMajor !== reqAdcpMajor) {
             return finalize(
               (0, import_errors2.adcpError)("VERSION_UNSUPPORTED", {
@@ -2878,7 +2918,7 @@ function createAdcpServer(config) {
             );
           }
         }
-        const effectiveReqMajor = reqAdcpMajor !== void 0 && Number.isFinite(reqAdcpMajor) ? reqAdcpMajor : typeof reqAdcpVersion === "string" ? (0, import_version.parseAdcpMajorVersion)(reqAdcpVersion) : void 0;
+        const effectiveReqMajor = reqAdcpMajor !== void 0 && Number.isFinite(reqAdcpMajor) ? reqAdcpMajor : typeof reqAdcpVersion === "string" ? (0, import_version2.parseAdcpMajorVersion)(reqAdcpVersion) : void 0;
         if (effectiveReqMajor !== void 0 && Number.isFinite(effectiveReqMajor)) {
           const supportedMajors = getAdvertisedSupportedMajors(capConfig, adcpVersion);
           if (!supportedMajors.has(effectiveReqMajor)) {
@@ -3447,7 +3487,24 @@ function createAdcpServer(config) {
               (_entry, index) => !notificationFailureRows.has(index)
             )
           };
-          const result = notificationFailureRows.size > 0 && handlerParams.accounts.length === 0 ? { accounts: [], ...params.dry_run === true && { dry_run: true } } : await handler(handlerParams, ctx);
+          const upgraded = translatesRelease ? (0, import_version.upgradeRequest)(toolName, handlerParams, {
+            fromVersion: requestRelease.validationVersion,
+            toVersion: adcpVersion
+          }) : void 0;
+          if (upgraded && upgraded.drifts.length > 0) {
+            logger.debug(`Converted ${toolName} request up to AdCP ${adcpVersion}`, {
+              tool: toolName,
+              drifts: upgraded.drifts
+            });
+            reportVersionTranslation({
+              tool: toolName,
+              direction: "request",
+              fromVersion: requestRelease.validationVersion,
+              toVersion: adcpVersion,
+              drifts: upgraded.drifts
+            });
+          }
+          const result = notificationFailureRows.size > 0 && handlerParams.accounts.length === 0 ? { accounts: [], ...params.dry_run === true && { dry_run: true } } : await handler(upgraded ? upgraded.params : handlerParams, ctx);
           mutationHandlerCompleted = true;
           let formatted;
           if (isFormattedResponse(result)) {
@@ -3915,6 +3972,31 @@ function createAdcpServer(config) {
               injectEnvelopeStatusIntoResponse(formatted, toolName);
             }
           }
+          if (translatesRelease && !isErrorResponse(formatted) && formatted.structuredContent) {
+            const downgraded = (0, import_version.downgradeResponse)(toolName, formatted.structuredContent, {
+              fromVersion: adcpVersion,
+              toVersion: requestRelease.validationVersion
+            });
+            if (downgraded.data !== formatted.structuredContent) {
+              const mirrors = contentTextMirrorsStructuredContent(formatted, formatted.structuredContent);
+              formatted = cloneFormattedResponse(formatted);
+              formatted.structuredContent = downgraded.data;
+              syncContentJsonText(formatted, downgraded.data, mirrors);
+            }
+            if (downgraded.drifts.length > 0) {
+              logger.info(`Converted ${toolName} response down to AdCP ${requestRelease.validationVersion}`, {
+                tool: toolName,
+                drifts: downgraded.drifts
+              });
+              reportVersionTranslation({
+                tool: toolName,
+                direction: "response",
+                fromVersion: adcpVersion,
+                toVersion: requestRelease.validationVersion,
+                drifts: downgraded.drifts
+              });
+            }
+          }
           if (responseValidationMode !== "off" && !isErrorResponse(formatted)) {
             const payload = formatted.structuredContent;
             const outcome = validateFrameworkPayload(
@@ -4630,7 +4712,7 @@ function createAdcpServer(config) {
       "measurement"
     ];
   }
-  capabilitiesData.library_version = `@adcp/client@${import_version2.LIBRARY_VERSION}`;
+  capabilitiesData.library_version = `@adcp/client@${import_version3.LIBRARY_VERSION}`;
   async function authorizeAuxiliaryIdentityTool(toolName, params, extra) {
     const failure = (0, import_web_bot_auth2.getWebBotAuthAuthorizationFailure)(extra?.authInfo?.extra);
     if (failure) return (0, import_web_bot_auth2.webBotAuthToolFailure)(failure, servedAdcpVersion);