@adcp/sdk 14.0.0-rc.38 → 14.0.0-rc.39

package/dist/lib/media-buy/preflight.d.ts

@@ -1,5 +1,9 @@
+import type { LiveMediaBuyAction as MediaBuyAvailableAction } from './action-types';
+import { type ActionAssessmentOptions } from './action-assessment';
 import { type AvailableActionsResult } from './available-actions';
-import type { ActionNotAllowedReason, MediaBuyActionContext, MediaBuyActionId, MediaBuyActionMode, MediaBuyAvailableAction, UpdateMediaBuyRequestLike } from './types';
+import type { ActionNotAllowedReason, MediaBuyActionContext, MediaBuyActionId, MediaBuyActionMode, UpdateMediaBuyRequestLike } from './types';
+import { type ResolvedAction, type DecomposedUpdateMediaBuyMutation } from './mutations';
+export * from './mutations';
 export declare const canPause: (buy: MediaBuyActionContext) => boolean;
 export declare const canResume: (buy: MediaBuyActionContext) => boolean;
 export declare const canCancel: (buy: MediaBuyActionContext) => boolean;
@@ -17,70 +21,6 @@ export declare const canUpdateCreativeAssignments: (buy: MediaBuyActionContext)
 export declare const canAddPackages: (buy: MediaBuyActionContext) => boolean;
 export declare const canRemovePackages: (buy: MediaBuyActionContext) => boolean;
 export declare const canRemoveCreative: (buy: MediaBuyActionContext) => boolean;
-export type MediaBuyMutationDirection = 'increase' | 'decrease' | 'reallocate' | 'extend' | 'shorten' | 'shift';
-/**
- * One action a request body covers, plus the direction inference where the
- * fine-grained vocabulary distinguishes increase/decrease or
- * extend/shorten. `touched_fields` lists the normalized dotted paths that
- * triggered this entry (useful for debugging).
- */
-export interface ResolvedAction {
-    action: MediaBuyActionId;
-    /**
-     * Direction tag. Present when the resolver picked between fine-grained
-     * siblings (e.g. `increase_budget` vs `decrease_budget`).
-     */
-    direction?: MediaBuyMutationDirection;
-    touched_fields: string[];
-}
-export type MediaBuyMutationScope = 'buy' | 'package' | 'packages';
-/**
- * One concrete requested mutation inside an `update_media_buy` patch.
- *
- * `field` is the normalized schema path used for action mapping
- * (`packages[].budget`), while `path` is the concrete request path
- * (`packages[0].budget`) that adopter code can use for diagnostics or
- * dispatch. `from` is best-effort and only populated for fields the helper can
- * read from the supplied current buy snapshot.
- */
-export interface DecomposedUpdateMediaBuyMutation {
-    action: MediaBuyActionId;
-    direction?: MediaBuyMutationDirection;
-    field: string;
-    path: string;
-    scope: MediaBuyMutationScope;
-    package_id?: string;
-    package_index?: number;
-    from?: unknown;
-    to?: unknown;
-}
-export interface DecomposedUpdateMediaBuy {
-    /** Concrete mutations requested by the patch. Empty when no known fields were touched. */
-    mutations: DecomposedUpdateMediaBuyMutation[];
-    /** Aggregated action view, preserving the legacy `getActionForMutation()` shape. */
-    actions: ResolvedAction[];
-    /** Unique normalized fields touched by this patch, in request traversal order. */
-    touched_fields: string[];
-}
-/**
- * Walk the request body and return the set of fine-grained actions it
- * covers. Compatibility wrapper over `decomposeUpdateMediaBuy()` for callers
- * that only need the action-level view.
- *
- * Returns an empty array when the request touches no recognized field
- * (e.g. only `idempotency_key` / `revision` / `account` were set).
- */
-export declare function getActionForMutation(currentBuy: MediaBuyActionContext, request: UpdateMediaBuyRequestLike): ResolvedAction[];
-/**
- * Decompose an `update_media_buy` patch into the concrete mutations it
- * requests plus the fine-grained actions those mutations require.
- *
- * This is intentionally read-only: it does not validate availability or
- * mutate the request. Buyer code can use it for previews and preflight;
- * seller/adopter code can use it to dispatch individual patch operations
- * without re-walking the raw request.
- */
-export declare function decomposeUpdateMediaBuy(currentBuy: MediaBuyActionContext, request: UpdateMediaBuyRequestLike): DecomposedUpdateMediaBuy;
 export interface PreflightAllowed {
     ok: true;
     /** Every action the request body covers. Multi-entry for mixed mutations. */
@@ -109,6 +49,10 @@ export interface PreflightDenial {
     reason: ActionNotAllowedReason;
     /** Structured recovery hint when `reason: 'mode_mismatch'`. */
     recovery?: ModeMismatchRecovery;
+    /** Portable bound or missing-state diagnostic, when accepted change terms were supplied. */
+    assessment?: Extract<import('./action-assessment').ActionAvailability, {
+        status: 'currently_unavailable';
+    }>;
 }
 export interface PreflightDenied {
     ok: false;
@@ -130,6 +74,9 @@ export type ModeMismatchRecovery = {
 } | {
     kind: 'waitForApproval';
     message: string;
+} | {
+    kind: 'waitForTask';
+    message: string;
 } | {
     kind: 'reissueAsDirect';
     message: string;
@@ -141,15 +88,19 @@ export type ModeMismatchRecovery = {
  * matching action - mode is not knowable, so it's reported as `self_serve`
  * but flagged as a compat fallback.
  *
+ * Supplying an accepted snapshot enables negotiated-term checks; separately stored
+ * snapshots use options.proposal. options.task defaults to the named update facade.
+ * For route-neutral strict assessment, use preflightMediaBuyActions.
+ *
  * Multi-action requests: every resolved action must be present in
  * `available_actions[]`. All missing actions are reported in `denials[]`
  * so callers can render every blocker in a single pass.
  *
- * Throws `ValidationError` when the request touches no recognized
- * `update_media_buy` field. This is a buyer-side bug (the SDK was asked to
+ * Throws `ValidationError` for unmapped mutation fields or when the request
+ * touches no recognized `update_media_buy` field. This is a buyer-side bug (the SDK was asked to
  * dispatch a no-op), not a seller-side denial.
  */
-export declare function preflightUpdateMediaBuy(currentBuy: MediaBuyActionContext, request: UpdateMediaBuyRequestLike): PreflightResult;
+export declare function preflightUpdateMediaBuy(currentBuy: MediaBuyActionContext, request: UpdateMediaBuyRequestLike, options?: Omit<ActionAssessmentOptions, 'request'>): PreflightResult;
 /**
  * Build a typed recovery hint from a `mode_mismatch` rejection. Exported
  * so callers handling `ActionNotAllowedError` outside of the preflight
@@ -157,4 +108,4 @@ export declare function preflightUpdateMediaBuy(currentBuy: MediaBuyActionContex
  * the same structured recovery path.
  */
 export declare function recoveryForModeMismatch(attemptedAction: MediaBuyActionId, currentlyAvailable: ReadonlyArray<MediaBuyAvailableAction>): ModeMismatchRecovery | undefined;
-export type { ActionNotAllowedReason, MediaBuyAvailableAction, MediaBuyActionId, MediaBuyActionMode, MediaBuyValidAction, MediaBuyActionContext, UpdateMediaBuyRequestLike, } from './types';
+export type { ActionNotAllowedReason, MediaBuyActionId, MediaBuyActionMode, MediaBuyValidAction, MediaBuyActionContext, UpdateMediaBuyRequestLike, } from './types';

package/dist/lib/media-buy/preflight.js

@@ -15,6 +15,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var preflight_exports = {};
 __export(preflight_exports, {
@@ -35,15 +36,28 @@ __export(preflight_exports, {
   canUpdateFrequencyCaps: () => canUpdateFrequencyCaps,
   canUpdatePacing: () => canUpdatePacing,
   canUpdateTargeting: () => canUpdateTargeting,
-  decomposeUpdateMediaBuy: () => decomposeUpdateMediaBuy,
-  getActionForMutation: () => getActionForMutation,
   preflightUpdateMediaBuy: () => preflightUpdateMediaBuy,
   recoveryForModeMismatch: () => recoveryForModeMismatch
 });
 module.exports = __toCommonJS(preflight_exports);
 var import_errors = require('../errors/index.js');
+var import_action_contracts = require('./action-contracts.js');
+var import_action_assessment = require('./action-assessment.js');
 var import_available_actions = require('./available-actions.js');
-var import_update_fields = require('./update-fields.generated.js');
+var import_action_metadata = require('./action-metadata.generated.js');
+var import_mutations = require('./mutations.js');
+__reExport(preflight_exports, require('./mutations.js'), module.exports);
+function tasksForLegacyMutation(action) {
+  const direct = (0, import_action_contracts.mediaBuyActionTasks)(action);
+  if (direct.length) return direct;
+  const children = Object.keys(import_action_metadata.CANONICAL_ACTION_TASKS).filter(
+    (child) => (0, import_available_actions.getRollupParent)(child) === action
+  );
+  if (!children.length) return [];
+  return (0, import_action_contracts.mediaBuyActionTasks)(children[0]).filter(
+    (task) => children.every((child) => (0, import_action_contracts.mediaBuyActionTasks)(child).includes(task))
+  );
+}
 function isAvailable(buy, action) {
   return (0, import_available_actions.findAvailableAction)(buy, action, { silent: true }) !== void 0;
 }
@@ -64,340 +78,23 @@ const canUpdateCreativeAssignments = (buy) => isAvailable(buy, "update_creative_
 const canAddPackages = (buy) => isAvailable(buy, "add_packages");
 const canRemovePackages = (buy) => isAvailable(buy, "remove_packages");
 const canRemoveCreative = (buy) => isAvailable(buy, "remove_creative");
-const BUDGET_EQUAL_TOLERANCE = 5e-3;
-function getActionForMutation(currentBuy, request) {
-  return decomposeUpdateMediaBuy(currentBuy, request).actions;
-}
-function decomposeUpdateMediaBuy(currentBuy, request) {
-  const mutations = [];
-  const currentPackages = /* @__PURE__ */ new Map();
-  for (const pkg of currentBuy.packages ?? []) {
-    if (pkg.package_id) currentPackages.set(pkg.package_id, pkg);
-  }
-  const push = (mutation) => {
-    mutations.push(mutation);
-  };
-  if (request.paused !== void 0) {
-    push({
-      action: request.paused === false ? "resume" : "pause",
-      field: "paused",
-      path: "paused",
-      scope: "buy",
-      to: request.paused
-    });
-  }
-  if (request.canceled !== void 0) {
-    push({
-      action: "cancel",
-      field: "canceled",
-      path: "canceled",
-      scope: "buy",
-      to: request.canceled
-    });
-  }
-  if (request.cancellation_reason !== void 0) {
-    push({
-      action: "cancel",
-      field: "cancellation_reason",
-      path: "cancellation_reason",
-      scope: "buy",
-      to: request.cancellation_reason
-    });
-  }
-  if (request.start_time !== void 0) {
-    push({
-      action: "update_flight_dates",
-      direction: "shift",
-      field: "start_time",
-      path: "start_time",
-      scope: "buy",
-      from: currentBuy.start_time,
-      to: request.start_time
-    });
-  }
-  if (request.end_time !== void 0) {
-    const pick = resolveFlightEndDirection(currentBuy, request, "end_time");
-    push({
-      ...pick,
-      field: "end_time",
-      path: "end_time",
-      scope: "buy",
-      from: currentBuy.end_time,
-      to: request.end_time
-    });
-  }
-  if (request.frequency_cap !== void 0) {
-    const [frequencyCapAction] = import_update_fields.ACTIONS_BY_FIELD["frequency_cap"] ?? [];
-    if (frequencyCapAction) {
-      push({
-        action: frequencyCapAction,
-        field: "frequency_cap",
-        path: "frequency_cap",
-        scope: "buy",
-        to: request.frequency_cap
-      });
-    }
-  }
-  if (request.new_packages !== void 0 && request.new_packages.length > 0) {
-    push({
-      action: "add_packages",
-      field: "new_packages",
-      path: "new_packages",
-      scope: "packages",
-      to: request.new_packages
-    });
-  }
-  if (request.packages) {
-    const budgetPick = resolveBudgetDirection(currentBuy, request);
-    const packageEndPick = resolveFlightEndDirection(currentBuy, request, "packages[].end_time");
-    request.packages.forEach((pkg, index) => {
-      const currentPkg = currentPackages.get(pkg.package_id);
-      const base = {
-        scope: "package",
-        package_id: pkg.package_id,
-        package_index: index
-      };
-      if (pkg.canceled !== void 0) {
-        push({
-          action: "remove_packages",
-          field: "packages[].canceled",
-          path: `packages[${index}].canceled`,
-          ...base,
-          to: pkg.canceled
-        });
-      }
-      if (pkg.budget !== void 0) {
-        push({
-          ...budgetPick,
-          field: "packages[].budget",
-          path: `packages[${index}].budget`,
-          ...base,
-          from: currentPkg?.budget,
-          to: pkg.budget
-        });
-      }
-      if (pkg.pacing !== void 0) {
-        push({
-          action: "update_pacing",
-          field: "packages[].pacing",
-          path: `packages[${index}].pacing`,
-          ...base,
-          to: pkg.pacing
-        });
-      }
-      if (pkg.start_time !== void 0) {
-        push({
-          action: "update_flight_dates",
-          direction: "shift",
-          field: "packages[].start_time",
-          path: `packages[${index}].start_time`,
-          ...base,
-          from: currentPkg?.start_time,
-          to: pkg.start_time
-        });
-      }
-      if (pkg.end_time !== void 0) {
-        push({
-          ...packageEndPick,
-          field: "packages[].end_time",
-          path: `packages[${index}].end_time`,
-          ...base,
-          from: currentPkg?.end_time,
-          to: pkg.end_time
-        });
-      }
-      if (pkg.creative_assignments !== void 0) {
-        push({
-          action: "update_creative_assignments",
-          field: "packages[].creative_assignments",
-          path: `packages[${index}].creative_assignments`,
-          ...base,
-          to: pkg.creative_assignments
-        });
-      }
-      if (pkg.creatives !== void 0) {
-        push({
-          action: "replace_creative",
-          field: "packages[].creatives",
-          path: `packages[${index}].creatives`,
-          ...base,
-          to: pkg.creatives
-        });
-      }
-      if (pkg.keyword_targets_add !== void 0) {
-        push({
-          action: "update_targeting",
-          field: "packages[].keyword_targets_add",
-          path: `packages[${index}].keyword_targets_add`,
-          ...base,
-          to: pkg.keyword_targets_add
-        });
-      }
-      if (pkg.keyword_targets_remove !== void 0) {
-        push({
-          action: "update_targeting",
-          field: "packages[].keyword_targets_remove",
-          path: `packages[${index}].keyword_targets_remove`,
-          ...base,
-          to: pkg.keyword_targets_remove
-        });
-      }
-      if (pkg.negative_keywords_add !== void 0) {
-        push({
-          action: "update_targeting",
-          field: "packages[].negative_keywords_add",
-          path: `packages[${index}].negative_keywords_add`,
-          ...base,
-          to: pkg.negative_keywords_add
-        });
-      }
-      if (pkg.negative_keywords_remove !== void 0) {
-        push({
-          action: "update_targeting",
-          field: "packages[].negative_keywords_remove",
-          path: `packages[${index}].negative_keywords_remove`,
-          ...base,
-          to: pkg.negative_keywords_remove
-        });
-      }
-      if (pkg.targeting_overlay !== void 0) {
-        const overlayKeys = Object.keys(pkg.targeting_overlay);
-        if (overlayKeys.length === 1 && overlayKeys[0] === "frequency_cap") {
-          push({
-            action: "update_frequency_caps",
-            field: "packages[].targeting_overlay.frequency_cap",
-            path: `packages[${index}].targeting_overlay.frequency_cap`,
-            ...base,
-            to: pkg.targeting_overlay.frequency_cap
-          });
-        } else {
-          push({
-            action: "update_targeting",
-            field: "packages[].targeting_overlay",
-            path: `packages[${index}].targeting_overlay`,
-            ...base,
-            to: pkg.targeting_overlay
-          });
-        }
-      }
-    });
-  }
-  return {
-    mutations,
-    actions: aggregateResolvedActions(mutations),
-    touched_fields: uniqueFields(mutations)
-  };
-}
-function aggregateResolvedActions(mutations) {
-  const resolved = /* @__PURE__ */ new Map();
-  for (const mutation of mutations) {
-    const existing = resolved.get(mutation.action);
-    if (existing) {
-      if (existing.direction === void 0 && mutation.direction !== void 0) {
-        existing.direction = mutation.direction;
-      }
-      if (!existing.touched_fields.includes(mutation.field)) {
-        existing.touched_fields.push(mutation.field);
-      }
-      continue;
-    }
-    resolved.set(mutation.action, {
-      action: mutation.action,
-      direction: mutation.direction,
-      touched_fields: [mutation.field]
-    });
-  }
-  return [...resolved.values()];
-}
-function uniqueFields(mutations) {
-  const fields = [];
-  for (const mutation of mutations) {
-    if (!fields.includes(mutation.field)) fields.push(mutation.field);
-  }
-  return fields;
-}
-function resolveBudgetDirection(currentBuy, request) {
-  const currentByPkg = /* @__PURE__ */ new Map();
-  for (const pkg of currentBuy.packages ?? []) {
-    if (pkg.package_id && typeof pkg.budget === "number") {
-      currentByPkg.set(pkg.package_id, pkg.budget);
-    }
-  }
-  let currentTotal = 0;
-  let proposedTotal = 0;
-  let sawIncrease = false;
-  let sawDecrease = false;
-  for (const pkg of request.packages ?? []) {
-    if (typeof pkg.budget !== "number") continue;
-    const prev = currentByPkg.get(pkg.package_id);
-    if (prev === void 0) {
-      sawIncrease = true;
-      proposedTotal += pkg.budget;
-      continue;
-    }
-    currentTotal += prev;
-    proposedTotal += pkg.budget;
-    if (pkg.budget > prev) sawIncrease = true;
-    if (pkg.budget < prev) sawDecrease = true;
-  }
-  if (sawIncrease && sawDecrease && Math.abs(proposedTotal - currentTotal) < BUDGET_EQUAL_TOLERANCE) {
-    return { action: "reallocate_budget", direction: "reallocate" };
-  }
-  if (proposedTotal > currentTotal) return { action: "increase_budget", direction: "increase" };
-  if (proposedTotal < currentTotal) return { action: "decrease_budget", direction: "decrease" };
-  return { action: "reallocate_budget", direction: "reallocate" };
-}
-function resolveFlightEndDirection(currentBuy, request, field) {
-  if (request.start_time !== void 0) {
-    return { action: "update_flight_dates", direction: "shift" };
-  }
-  const packageStartTouched = (request.packages ?? []).some((pkg) => pkg.start_time !== void 0);
-  if (packageStartTouched) {
-    return { action: "update_flight_dates", direction: "shift" };
-  }
-  if (field === "end_time") {
-    const currentEnd = currentBuy.end_time;
-    const proposedEnd = request.end_time;
-    if (currentEnd && proposedEnd) {
-      const cur = Date.parse(currentEnd);
-      const next = Date.parse(proposedEnd);
-      if (!Number.isNaN(cur) && !Number.isNaN(next)) {
-        if (next > cur) return { action: "extend_flight", direction: "extend" };
-        if (next < cur) return { action: "shorten_flight", direction: "shorten" };
-      }
-    }
-    return { action: "update_flight_dates", direction: "shift" };
-  }
-  let extending = false;
-  let shortening = false;
-  const currentByPkg = /* @__PURE__ */ new Map();
-  for (const pkg of currentBuy.packages ?? []) {
-    if (pkg.package_id) currentByPkg.set(pkg.package_id, pkg.end_time);
-  }
-  for (const pkg of request.packages ?? []) {
-    if (!pkg.end_time) continue;
-    const prev = currentByPkg.get(pkg.package_id);
-    if (!prev) {
-      extending = true;
-      continue;
-    }
-    const cur = Date.parse(prev);
-    const next = Date.parse(pkg.end_time);
-    if (Number.isNaN(cur) || Number.isNaN(next)) continue;
-    if (next > cur) extending = true;
-    if (next < cur) shortening = true;
-  }
-  if (extending && !shortening) return { action: "extend_flight", direction: "extend" };
-  if (shortening && !extending) return { action: "shorten_flight", direction: "shorten" };
-  return { action: "update_flight_dates", direction: "shift" };
-}
-function preflightUpdateMediaBuy(currentBuy, request) {
-  const decomposition = decomposeUpdateMediaBuy(currentBuy, request);
+function preflightUpdateMediaBuy(currentBuy, request, options = {}) {
+  const assessmentBuy = currentBuy;
+  currentBuy = (0, import_action_contracts.withActionProposal)(currentBuy, options);
+  options = { ...options, task: options.task ?? "update_media_buy" };
+  const decomposition = (0, import_mutations.decomposeUpdateMediaBuy)(currentBuy, request);
   const resolved = decomposition.actions;
+  const strict = currentBuy.accepted_proposal?.commercial_terms?.change_terms !== void 0 || currentBuy.available_actions?.some((entry) => entry?.change_term_id !== void 0) === true;
+  if ((0, import_mutations.hasUnmappedMutation)(request, decomposition))
+    throw new import_errors.ValidationError(
+      "request",
+      void 0,
+      "At least one requested mutation has no supported action mapping; do not submit a partial mutation."
+    );
   if (resolved.length === 0) {
     throw new import_errors.ValidationError(
       "request",
-      request,
+      void 0,
       "update_media_buy request must touch at least one mutating field (paused, canceled, start_time, end_time, frequency_cap, packages[*], or new_packages)"
     );
   }
@@ -407,14 +104,77 @@ function preflightUpdateMediaBuy(currentBuy, request) {
   const modes = [];
   const denials = [];
   for (const resolvedAction of resolved) {
+    if (!strict && (resolvedAction.action === "pause" || resolvedAction.action === "resume")) {
+      const controls = decomposition.mutations.filter(
+        (mutation) => mutation.action === resolvedAction.action && mutation.field === "packages[].paused"
+      );
+      if (controls.length) {
+        const statuses = controls.map(
+          (mutation) => (0, import_action_contracts.packageActionStatus)(currentBuy.packages?.find((pkg) => pkg.package_id === mutation.package_id))
+        );
+        const allowed = (0, import_action_contracts.actionAllowedStatuses)({ action: resolvedAction.action });
+        if (currentBuy.status === void 0 || statuses.some((status) => status === void 0)) {
+          denials.push({ action: resolvedAction.action, reason: "condition_unresolved" });
+          continue;
+        }
+        if (!["active", "paused"].includes(currentBuy.status) || statuses.some((status) => !allowed.includes(status))) {
+          denials.push({ action: resolvedAction.action, reason: "wrong_status" });
+          continue;
+        }
+      }
+    }
+    if (strict || options.proposal !== void 0 || resolvedAction.action === "update_name") {
+      const assessment = (0, import_action_assessment.assessActionAvailability)(assessmentBuy, resolvedAction.action, { ...options, request });
+      if (assessment.status === "currently_unavailable") {
+        denials.push({ action: resolvedAction.action, reason: assessment.reason, assessment });
+        continue;
+      }
+    }
     const lookup = (0, import_available_actions.findAvailableAction)(currentBuy, resolvedAction.action, { silent: true });
     if (!lookup) {
       denials.push({ action: resolvedAction.action, reason: "not_supported_on_buy" });
       continue;
     }
+    if (options.adcpVersion && !(0, import_action_contracts.liveActionFitsVersion)(lookup.entry, options.adcpVersion)) {
+      denials.push({
+        action: resolvedAction.action,
+        reason: "condition_unresolved",
+        assessment: {
+          status: "currently_unavailable",
+          action: resolvedAction.action,
+          reason: "condition_unresolved",
+          certainty: "unknown",
+          message: "The action uses metadata introduced after the supplied seller version."
+        }
+      });
+      continue;
+    }
+    if (!strict && lookup.entry.task !== void 0 && !tasksForLegacyMutation(resolvedAction.action).includes(lookup.entry.task)) {
+      denials.push({ action: resolvedAction.action, reason: "mode_mismatch" });
+      continue;
+    }
+    if (!strict && lookup.entry.applicable_package_ids !== void 0) {
+      const scoped = decomposition.mutations.filter((m) => m.action === resolvedAction.action);
+      const ids = lookup.entry.applicable_package_ids;
+      if ((0, import_action_contracts.liveActionIssues)([lookup.entry]).length || !scoped.length) {
+        denials.push({ action: resolvedAction.action, reason: "condition_unresolved" });
+        continue;
+      }
+      if (scoped.some((m) => m.scope !== "package" || !m.package_id || !ids.includes(m.package_id))) {
+        denials.push({ action: resolvedAction.action, reason: "not_supported_on_buy" });
+        continue;
+      }
+    }
+    if (!strict && options.task !== "update_media_buy" && options.task !== (lookup.entry.task ?? "update_media_buy")) {
+      denials.push({ action: resolvedAction.action, reason: "mode_mismatch" });
+      continue;
+    }
     matched.push(lookup.entry);
     modes.push(lookup.entry.mode);
   }
+  if (strict && options.task !== "update_media_buy" && denials.length === 0 && new Set(matched.map((entry) => entry.task ?? "update_media_buy")).size > 1) {
+    for (const action of resolved) denials.push({ action: action.action, reason: "mode_mismatch" });
+  }
   if (denials.length > 0) {
     return {
       ok: false,
@@ -438,6 +198,11 @@ function recoveryForModeMismatch(attemptedAction, currentlyAvailable) {
   const entry = currentlyAvailable.find((a) => a.action === attemptedAction);
   if (!entry) return void 0;
   switch (entry.mode) {
+    case "seller_managed":
+      return {
+        kind: "waitForTask",
+        message: "Use the declared task and follow its submitted/working/completed lifecycle."
+      };
     case "requires_proposal":
       return {
         kind: "createProposal",
@@ -481,8 +246,7 @@ function recoveryForModeMismatch(attemptedAction, currentlyAvailable) {
   canUpdateFrequencyCaps,
   canUpdatePacing,
   canUpdateTargeting,
-  decomposeUpdateMediaBuy,
-  getActionForMutation,
   preflightUpdateMediaBuy,
-  recoveryForModeMismatch
+  recoveryForModeMismatch,
+  ...require('./mutations.js')
 });