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

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

@@ -0,0 +1,77 @@
+import type { ActionNotAllowedReason, UpdateMediaBuyRequestLike } from './types';
+import type { ActionBuy, ActionProduct, ActionProposal, ConstraintAssessment, LiveMediaBuyAction, MediaBuyAction, MediaBuyStatus, MediaBuyTask, ProductActionAssessment, ProposalActionAssessment, ProposalChangeTerm } from './action-types';
+import { type ConstraintEvaluationOptions } from './action-constraints';
+export interface ActionAssessmentOptions extends ConstraintEvaluationOptions {
+    /** Seller-served wire version. 3.1 term references are always opaque. Defaults to the current 3.2 shape. */
+    adcpVersion?: string;
+    /** Explicit 3.2 compatibility projection declaring terms_ref an alias for change_term_id. */
+    termsRefIsAlias?: boolean;
+    /** Current accepted snapshot when it is stored separately from the buy. An embedded snapshot takes precedence. */
+    proposal?: ActionProposal;
+    /** Optional route being attempted. update_media_buy can subsume compact tasks as a compatibility facade. */
+    task?: MediaBuyTask;
+    request?: UpdateMediaBuyRequestLike;
+}
+export type ActionAvailability = {
+    status: 'available_now';
+    action: MediaBuyAction;
+    mode: LiveMediaBuyAction['mode'];
+    nonDefaultRoute?: MediaBuyTask;
+    /** Metadata changes have live seller authority and no commercial promise. */
+    authority: 'accepted_term' | 'live_metadata';
+    term?: ProposalChangeTerm;
+    entry: LiveMediaBuyAction;
+    revision?: number;
+    constraints?: ConstraintAssessment;
+} | {
+    status: 'currently_unavailable';
+    action: MediaBuyAction;
+    reason: ActionNotAllowedReason;
+    message: string;
+    certainty: 'blocked' | 'unknown';
+    allowedStatuses?: MediaBuyStatus[];
+    nonDefaultRoute?: MediaBuyTask;
+    constraints?: ConstraintAssessment;
+    code?: 'REQUOTE_REQUIRED' | 'CONFLICT';
+    compat?: {
+        reason: 'no_change_terms';
+        message: string;
+    };
+};
+export interface MediaBuyActionAssessment {
+    action: MediaBuyAction;
+    possibility: ProductActionAssessment;
+    promise: ProposalActionAssessment;
+    availability: ActionAvailability;
+}
+/** Product templates are possibility, including their advisory bounds, never acceptance. */
+export declare function assessProductAction(product: ActionProduct | undefined, action: MediaBuyAction): ProductActionAssessment;
+/** Reports what the proposal promises; it does not verify a digest or accept the proposal. */
+export declare function assessProposalAction(proposal: ActionProposal | undefined, action: MediaBuyAction): ProposalActionAssessment;
+/**
+ * Join the current accepted snapshot and action projection. Pure, synchronous,
+ * browser-safe, and read-only. This is preflight evidence, not authorization or
+ * an atomic revision check. Submit with the existing client lifecycle safeguards.
+ */
+export declare function assessActionAvailability(buy: ActionBuy | undefined, action: MediaBuyAction, options?: ActionAssessmentOptions): ActionAvailability;
+/** Render possible / promised / available-now from one call. Product data never creates a promise. */
+export declare function assessMediaBuyAction(input: {
+    action: MediaBuyAction;
+    product?: ActionProduct;
+    proposal?: ActionProposal;
+    buy?: ActionBuy;
+} & ActionAssessmentOptions): MediaBuyActionAssessment;
+/** ACTION_NOT_ALLOWED echoes replace the action set, including an explicit empty set. They never update revision or accepted terms. */
+export declare function refreshMediaBuyActions<T extends ActionBuy>(buy: T, details: unknown): T;
+export type MediaBuyActionsPreflight = {
+    ok: true;
+    assessments: Extract<ActionAvailability, {
+        status: 'available_now';
+    }>[];
+} | {
+    ok: false;
+    assessments: ActionAvailability[];
+    message?: string;
+};
+/** Assess every decomposed action atomically; never send a partial multi-action request. */
+export declare function preflightMediaBuyActions(buy: ActionBuy, request: UpdateMediaBuyRequestLike, options?: Omit<ActionAssessmentOptions, 'request'>): MediaBuyActionsPreflight;

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

@@ -0,0 +1,300 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var action_assessment_exports = {};
+__export(action_assessment_exports, {
+  assessActionAvailability: () => assessActionAvailability,
+  assessMediaBuyAction: () => assessMediaBuyAction,
+  assessProductAction: () => assessProductAction,
+  assessProposalAction: () => assessProposalAction,
+  preflightMediaBuyActions: () => preflightMediaBuyActions,
+  refreshMediaBuyActions: () => refreshMediaBuyActions
+});
+module.exports = __toCommonJS(action_assessment_exports);
+var import_action_contracts = require('./action-contracts.js');
+var import_action_constraints = require('./action-constraints.js');
+var import_mutations = require('./mutations.js');
+function assessProductAction(product, action) {
+  if (product?.allowed_actions === void 0)
+    return { status: "unknown", binding: false, message: "Product action information is absent." };
+  if ((0, import_action_contracts.productTemplateIssues)(product.allowed_actions).length)
+    return { status: "unknown", binding: false, message: "Product action information is invalid or ambiguous." };
+  const template = (0, import_action_contracts.findProductAction)(product.allowed_actions, action);
+  return template ? { status: "possible", binding: false, template } : { status: "unsupported", binding: false };
+}
+function assessProposalAction(proposal, action) {
+  const terms = proposal?.commercial_terms?.change_terms;
+  if (terms === void 0) return { status: "unknown", message: "Proposal change terms are absent." };
+  if ((0, import_action_contracts.changeTermIssues)(terms).length)
+    return { status: "unknown", message: "Proposal change terms are invalid or ambiguous." };
+  const term = terms.find((t) => t.action === action);
+  return term ? { status: "promised", term } : { status: "not_negotiated" };
+}
+function assessActionAvailability(buy, action, options = {}) {
+  const deny = (reason, message, certainty = "blocked", extra = {}) => ({ status: "currently_unavailable", action, reason, message, certainty, ...extra });
+  if (options.request !== void 0 && (0, import_mutations.mutationShapeIssue)(options.request))
+    return deny(
+      "condition_unresolved",
+      "Invalid mutation field shape; validate against the selected wire schema.",
+      "unknown"
+    );
+  if (!buy) return deny("condition_unresolved", "Current MediaBuy state is missing.", "unknown");
+  if (options.request?.packages?.length) {
+    const requested = options.request.packages.map((p) => p.package_id);
+    const current = buy.packages?.map((p) => p.package_id);
+    if (!current || new Set(requested).size !== requested.length || new Set(current).size !== current.length || requested.some((id) => !id || !current.includes(id)))
+      return deny(
+        "condition_unresolved",
+        "Package identities or current package state are missing or ambiguous.",
+        "unknown"
+      );
+  }
+  if (buy.accepted_proposal === void 0 && options.proposal !== void 0) {
+    const supplied = options.proposal;
+    const linked = buy.accepted_proposal_id !== void 0 && supplied.proposal_id === buy.accepted_proposal_id || buy.media_buy_id !== void 0 && supplied.media_buy_id === buy.media_buy_id;
+    if (!linked || supplied.proposal_status !== "accepted")
+      return deny(
+        "condition_unresolved",
+        "The separately supplied snapshot must be accepted and explicitly linked to this MediaBuy.",
+        "unknown"
+      );
+  }
+  buy = (0, import_action_contracts.withActionProposal)(buy, options);
+  const decomposition = options.request ? (0, import_mutations.decomposeUpdateMediaBuy)(buy, options.request) : void 0;
+  if (options.request && decomposition && (0, import_mutations.hasUnmappedMutation)(options.request, decomposition))
+    return deny(
+      "condition_unresolved",
+      "At least one requested field has no supported action mapping; executable-now assessment requires a fully mapped request.",
+      "unknown"
+    );
+  const metadataOnly = action === "update_name";
+  const proposal = buy.accepted_proposal;
+  const terms = proposal?.commercial_terms?.change_terms;
+  if (terms === void 0 && !metadataOnly)
+    return deny("condition_unresolved", "Accepted change rights are unknown.", "unknown", {
+      compat: {
+        reason: "no_change_terms",
+        message: "Legacy action hints and opaque references do not establish a negotiated change right."
+      }
+    });
+  if (!(0, import_action_contracts.mediaBuyActionTasks)(action).length)
+    return deny(
+      "condition_unresolved",
+      "A canonical action cannot be inferred from this legacy or incomplete mutation state.",
+      "unknown"
+    );
+  if (proposal !== void 0 && buy.accepted_proposal_id !== void 0 && proposal.proposal_id !== buy.accepted_proposal_id || proposal?.media_buy_id !== void 0 && proposal.media_buy_id !== buy.media_buy_id || proposal?.proposal_status !== void 0 && proposal.proposal_status !== "accepted")
+    return deny("condition_unresolved", "The supplied proposal is not the current accepted snapshot.", "unknown");
+  const promise = assessProposalAction(proposal, action);
+  if (!metadataOnly && promise.status === "unknown") return deny("condition_unresolved", promise.message, "unknown");
+  if (!metadataOnly && promise.status === "not_negotiated")
+    return deny("not_supported_on_buy", "This action was not negotiated in the accepted proposal.");
+  const term = promise.status === "promised" ? promise.term : void 0;
+  const packageLifecycle = ["pause", "resume"].includes(action) && options.request?.packages?.filter((p) => p.paused !== void 0 && (p.paused ? "pause" : "resume") === action);
+  const scopedLifecycle = packageLifecycle && packageLifecycle.length > 0 && options.request?.paused === void 0;
+  const packageControlStatuses = scopedLifecycle ? [...(0, import_action_contracts.actionAllowedStatuses)({ action: "pause" }), ...(0, import_action_contracts.actionAllowedStatuses)({ action: "resume" })] : [];
+  const allowedStatuses = metadataOnly ? [...import_action_contracts.NON_TERMINAL_ACTION_STATUSES] : scopedLifecycle ? import_action_contracts.NON_TERMINAL_ACTION_STATUSES.filter(
+    (status) => term?.allowed_statuses ? term.allowed_statuses.includes(status) : packageControlStatuses.includes(status)
+  ) : (0, import_action_contracts.actionAllowedStatuses)(term);
+  for (const pkg of packageLifecycle || []) {
+    const current = buy.packages?.find((p) => p.package_id === pkg.package_id);
+    const status = (0, import_action_contracts.packageActionStatus)(current);
+    if (!status) return deny("condition_unresolved", "Current package lifecycle state is missing.", "unknown");
+    if (!(0, import_action_contracts.actionAllowedStatuses)({ action }).includes(status))
+      return deny("wrong_status", "The action is not meaningful in the current package status.");
+  }
+  if (buy.status === void 0) return deny("condition_unresolved", "Current MediaBuy status is missing.", "unknown");
+  if (!allowedStatuses.includes(buy.status))
+    return deny("wrong_status", "The negotiated action is latent in the current status.", "blocked", {
+      allowedStatuses
+    });
+  if (options.request?.revision !== void 0 && (buy.revision === void 0 || options.request.revision !== buy.revision))
+    return deny("condition_unresolved", "Refresh the MediaBuy revision and reassess before submitting.", "unknown", {
+      code: "CONFLICT"
+    });
+  if (term?.conditions?.length)
+    return deny(
+      "condition_unresolved",
+      "Opaque conditions require seller evaluation; their identifiers grant no authority.",
+      "unknown"
+    );
+  const entries = buy.available_actions;
+  if (entries === void 0)
+    return deny(
+      "condition_unresolved",
+      "A current structured action projection is required; legacy hints have no mode or term identity.",
+      "unknown"
+    );
+  if ((0, import_action_contracts.liveActionIssues)(entries).length)
+    return deny("condition_unresolved", "The live action projection is invalid or ambiguous.", "unknown");
+  const entry = entries.find((e) => e.action === action);
+  if (options.adcpVersion && entry && !(0, import_action_contracts.liveActionFitsVersion)(entry, options.adcpVersion))
+    return deny(
+      "condition_unresolved",
+      "The action uses metadata introduced after the supplied seller version.",
+      "unknown"
+    );
+  if (!entry)
+    return deny("not_supported_on_buy", "The seller has not made this negotiated action available now.", "unknown");
+  if (!metadataOnly && options.adcpVersion && !(0, import_action_contracts.supportsChangeTermIdentity)(options.adcpVersion))
+    return deny(
+      "condition_unresolved",
+      "The supplied seller version cannot link accepted change terms; legacy terms_ref remains opaque.",
+      "unknown"
+    );
+  if (!metadataOnly && (entry.change_term_id === void 0 || entry.change_term_id !== term.term_id))
+    return deny("condition_unresolved", "The live action does not identify its accepted change term.", "unknown");
+  if (options.termsRefIsAlias && entry.change_term_id !== void 0 && entry.terms_ref !== void 0 && entry.terms_ref !== entry.change_term_id)
+    return deny("condition_unresolved", "The deliberately emitted term aliases disagree.", "unknown");
+  if (metadataOnly && entry.change_term_id !== void 0)
+    return deny("condition_unresolved", "Metadata-only actions cannot identify a commercial change term.", "unknown");
+  if (!["self_serve", "conditional_self_serve", "seller_managed", "requires_approval"].includes(entry.mode))
+    return deny("condition_unresolved", "Unknown live action mode; refresh the seller declaration.", "unknown");
+  if (term && (entry.mode !== term.service_mode || !(0, import_action_contracts.slaWithin)(term.processing_sla, entry.sla)))
+    return deny("mode_mismatch", "The live mode or SLA exceeds the accepted commitment.");
+  if (entry.task !== void 0 && !(0, import_action_contracts.mediaBuyActionTasks)(action).includes(entry.task))
+    return deny("mode_mismatch", "The live action has no compatible canonical task.");
+  const task = entry.task ?? "update_media_buy";
+  const nonDefaultRoute = task === "update_media_buy" ? void 0 : task;
+  if (options.task !== void 0 && options.task !== "update_media_buy" && options.task !== task)
+    return deny(
+      "mode_mismatch",
+      entry.task === void 0 ? "This task-less entry uses update_media_buy. Refresh get_media_buys for a canonical task projection before changing routes." : "Use the task declared by the live action; seller_managed uses its standard async lifecycle.",
+      "blocked",
+      { nonDefaultRoute }
+    );
+  const mutations = decomposition?.mutations ?? [];
+  if (entry.applicable_package_ids !== void 0) {
+    const ids = entry.applicable_package_ids;
+    if (!Array.isArray(ids) || !ids.length || ids.some((id) => typeof id !== "string" || !id.length) || new Set(ids).size !== ids.length)
+      return deny("condition_unresolved", "Invalid live package scope.", "unknown");
+    const relevant = mutations.filter((m) => m.action === action);
+    if (!relevant.length)
+      return deny(
+        "condition_unresolved",
+        "Supply the requested packages to evaluate the live package scope.",
+        "unknown"
+      );
+    if (relevant.some((m) => m.scope !== "package" || !m.package_id || !ids.includes(m.package_id)))
+      return deny("not_supported_on_buy", "The action is not available for every requested package.");
+  }
+  let constraints;
+  if (term && (term.constraints !== void 0 || options.request)) {
+    constraints = options.request ? (0, import_action_constraints.evaluateChangeTermConstraints)(term, buy, options.request, mutations, options) : {
+      status: "unknown",
+      constraint: "request",
+      path: action,
+      message: "Supply the requested mutation to evaluate portable bounds."
+    };
+    if (constraints.status !== "satisfied")
+      return deny(
+        "condition_unresolved",
+        constraints.message,
+        constraints.status === "unknown" ? "unknown" : "blocked",
+        {
+          constraints,
+          ...constraints.status === "exceeded" && { code: "REQUOTE_REQUIRED" }
+        }
+      );
+  }
+  if (action === "add_packages" && options.request?.new_packages) {
+    const index = options.request.new_packages.findIndex(
+      (pkg) => pkg !== null && typeof pkg === "object" && ["budget", "min_spend_target", "daily_budget_cap"].some(
+        (field) => Object.hasOwn(pkg, field) && pkg[field] !== void 0
+      )
+    );
+    if (index !== -1)
+      return deny(
+        "condition_unresolved",
+        "Added-package monetary commitments cannot be assessed from package-count rights alone.",
+        "unknown",
+        {
+          constraints: {
+            status: "unknown",
+            constraint: "added_package_budget",
+            path: `new_packages[${index}]`,
+            message: "Supply a verified commercial amendment for the added package commitments; their budget baseline is not represented by this portable patch assessment."
+          }
+        }
+      );
+  }
+  return {
+    status: "available_now",
+    action,
+    mode: entry.mode,
+    nonDefaultRoute,
+    authority: metadataOnly ? "live_metadata" : "accepted_term",
+    ...term && { term },
+    entry,
+    revision: buy.revision,
+    ...constraints && { constraints }
+  };
+}
+function assessMediaBuyAction(input) {
+  const possibility = assessProductAction(input.product, input.action);
+  const promise = assessProposalAction(input.buy?.accepted_proposal ?? input.proposal, input.action);
+  const availability = assessActionAvailability(input.buy, input.action, input);
+  return { action: input.action, possibility, promise, availability };
+}
+function refreshMediaBuyActions(buy, details) {
+  if (!details || typeof details !== "object" || !("currently_available_actions" in details) || details.currently_available_actions === void 0)
+    return buy;
+  const entries = details.currently_available_actions;
+  if ((0, import_action_contracts.liveActionIssues)(entries).length) throw new TypeError("Invalid ACTION_NOT_ALLOWED action echo.");
+  return { ...buy, available_actions: structuredClone(entries) };
+}
+function preflightMediaBuyActions(buy, request, options = {}) {
+  const assessmentBuy = buy;
+  buy = (0, import_action_contracts.withActionProposal)(buy, options);
+  const shapeIssue = (0, import_mutations.mutationShapeIssue)(request);
+  if (shapeIssue) return { ok: false, assessments: [], message: `Invalid mutation field shape at ${shapeIssue}.` };
+  const decomposition = (0, import_mutations.decomposeUpdateMediaBuy)(buy, request);
+  const unresolvedField = (0, import_mutations.hasUnmappedMutation)(request, decomposition);
+  if (unresolvedField)
+    return {
+      ok: false,
+      assessments: [],
+      message: "At least one requested field has no supported action mapping; do not submit a partial mutation."
+    };
+  if (!decomposition.actions.length)
+    return { ok: false, assessments: [], message: "No recognized mutation could be assessed." };
+  const assessments = decomposition.actions.map(
+    ({ action }) => assessActionAvailability(assessmentBuy, action, { ...options, request })
+  );
+  if (assessments.every(
+    (a) => a.status === "available_now"
+  )) {
+    if (options.task !== "update_media_buy" && new Set(assessments.map((a) => a.nonDefaultRoute ?? "update_media_buy")).size > 1)
+      return {
+        ok: false,
+        assessments,
+        message: "The requested actions declare different compact tasks. Pass task: update_media_buy to assess the whole mutation through the compatibility facade."
+      };
+    return { ok: true, assessments };
+  }
+  return { ok: false, assessments };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assessActionAvailability,
+  assessMediaBuyAction,
+  assessProductAction,
+  assessProposalAction,
+  preflightMediaBuyActions,
+  refreshMediaBuyActions
+});

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

@@ -0,0 +1,284 @@
+import {
+  actionAllowedStatuses,
+  changeTermIssues,
+  mediaBuyActionTasks,
+  productTemplateIssues,
+  slaWithin,
+  findProductAction,
+  NON_TERMINAL_ACTION_STATUSES,
+  liveActionIssues,
+  liveActionFitsVersion,
+  supportsChangeTermIdentity,
+  withActionProposal,
+  packageActionStatus
+} from "./action-contracts.mjs";
+import { evaluateChangeTermConstraints } from "./action-constraints.mjs";
+import { decomposeUpdateMediaBuy, hasUnmappedMutation, mutationShapeIssue } from "./mutations.mjs";
+function assessProductAction(product, action) {
+  if (product?.allowed_actions === void 0)
+    return { status: "unknown", binding: false, message: "Product action information is absent." };
+  if (productTemplateIssues(product.allowed_actions).length)
+    return { status: "unknown", binding: false, message: "Product action information is invalid or ambiguous." };
+  const template = findProductAction(product.allowed_actions, action);
+  return template ? { status: "possible", binding: false, template } : { status: "unsupported", binding: false };
+}
+function assessProposalAction(proposal, action) {
+  const terms = proposal?.commercial_terms?.change_terms;
+  if (terms === void 0) return { status: "unknown", message: "Proposal change terms are absent." };
+  if (changeTermIssues(terms).length)
+    return { status: "unknown", message: "Proposal change terms are invalid or ambiguous." };
+  const term = terms.find((t) => t.action === action);
+  return term ? { status: "promised", term } : { status: "not_negotiated" };
+}
+function assessActionAvailability(buy, action, options = {}) {
+  const deny = (reason, message, certainty = "blocked", extra = {}) => ({ status: "currently_unavailable", action, reason, message, certainty, ...extra });
+  if (options.request !== void 0 && mutationShapeIssue(options.request))
+    return deny(
+      "condition_unresolved",
+      "Invalid mutation field shape; validate against the selected wire schema.",
+      "unknown"
+    );
+  if (!buy) return deny("condition_unresolved", "Current MediaBuy state is missing.", "unknown");
+  if (options.request?.packages?.length) {
+    const requested = options.request.packages.map((p) => p.package_id);
+    const current = buy.packages?.map((p) => p.package_id);
+    if (!current || new Set(requested).size !== requested.length || new Set(current).size !== current.length || requested.some((id) => !id || !current.includes(id)))
+      return deny(
+        "condition_unresolved",
+        "Package identities or current package state are missing or ambiguous.",
+        "unknown"
+      );
+  }
+  if (buy.accepted_proposal === void 0 && options.proposal !== void 0) {
+    const supplied = options.proposal;
+    const linked = buy.accepted_proposal_id !== void 0 && supplied.proposal_id === buy.accepted_proposal_id || buy.media_buy_id !== void 0 && supplied.media_buy_id === buy.media_buy_id;
+    if (!linked || supplied.proposal_status !== "accepted")
+      return deny(
+        "condition_unresolved",
+        "The separately supplied snapshot must be accepted and explicitly linked to this MediaBuy.",
+        "unknown"
+      );
+  }
+  buy = withActionProposal(buy, options);
+  const decomposition = options.request ? decomposeUpdateMediaBuy(buy, options.request) : void 0;
+  if (options.request && decomposition && hasUnmappedMutation(options.request, decomposition))
+    return deny(
+      "condition_unresolved",
+      "At least one requested field has no supported action mapping; executable-now assessment requires a fully mapped request.",
+      "unknown"
+    );
+  const metadataOnly = action === "update_name";
+  const proposal = buy.accepted_proposal;
+  const terms = proposal?.commercial_terms?.change_terms;
+  if (terms === void 0 && !metadataOnly)
+    return deny("condition_unresolved", "Accepted change rights are unknown.", "unknown", {
+      compat: {
+        reason: "no_change_terms",
+        message: "Legacy action hints and opaque references do not establish a negotiated change right."
+      }
+    });
+  if (!mediaBuyActionTasks(action).length)
+    return deny(
+      "condition_unresolved",
+      "A canonical action cannot be inferred from this legacy or incomplete mutation state.",
+      "unknown"
+    );
+  if (proposal !== void 0 && buy.accepted_proposal_id !== void 0 && proposal.proposal_id !== buy.accepted_proposal_id || proposal?.media_buy_id !== void 0 && proposal.media_buy_id !== buy.media_buy_id || proposal?.proposal_status !== void 0 && proposal.proposal_status !== "accepted")
+    return deny("condition_unresolved", "The supplied proposal is not the current accepted snapshot.", "unknown");
+  const promise = assessProposalAction(proposal, action);
+  if (!metadataOnly && promise.status === "unknown") return deny("condition_unresolved", promise.message, "unknown");
+  if (!metadataOnly && promise.status === "not_negotiated")
+    return deny("not_supported_on_buy", "This action was not negotiated in the accepted proposal.");
+  const term = promise.status === "promised" ? promise.term : void 0;
+  const packageLifecycle = ["pause", "resume"].includes(action) && options.request?.packages?.filter((p) => p.paused !== void 0 && (p.paused ? "pause" : "resume") === action);
+  const scopedLifecycle = packageLifecycle && packageLifecycle.length > 0 && options.request?.paused === void 0;
+  const packageControlStatuses = scopedLifecycle ? [...actionAllowedStatuses({ action: "pause" }), ...actionAllowedStatuses({ action: "resume" })] : [];
+  const allowedStatuses = metadataOnly ? [...NON_TERMINAL_ACTION_STATUSES] : scopedLifecycle ? NON_TERMINAL_ACTION_STATUSES.filter(
+    (status) => term?.allowed_statuses ? term.allowed_statuses.includes(status) : packageControlStatuses.includes(status)
+  ) : actionAllowedStatuses(term);
+  for (const pkg of packageLifecycle || []) {
+    const current = buy.packages?.find((p) => p.package_id === pkg.package_id);
+    const status = packageActionStatus(current);
+    if (!status) return deny("condition_unresolved", "Current package lifecycle state is missing.", "unknown");
+    if (!actionAllowedStatuses({ action }).includes(status))
+      return deny("wrong_status", "The action is not meaningful in the current package status.");
+  }
+  if (buy.status === void 0) return deny("condition_unresolved", "Current MediaBuy status is missing.", "unknown");
+  if (!allowedStatuses.includes(buy.status))
+    return deny("wrong_status", "The negotiated action is latent in the current status.", "blocked", {
+      allowedStatuses
+    });
+  if (options.request?.revision !== void 0 && (buy.revision === void 0 || options.request.revision !== buy.revision))
+    return deny("condition_unresolved", "Refresh the MediaBuy revision and reassess before submitting.", "unknown", {
+      code: "CONFLICT"
+    });
+  if (term?.conditions?.length)
+    return deny(
+      "condition_unresolved",
+      "Opaque conditions require seller evaluation; their identifiers grant no authority.",
+      "unknown"
+    );
+  const entries = buy.available_actions;
+  if (entries === void 0)
+    return deny(
+      "condition_unresolved",
+      "A current structured action projection is required; legacy hints have no mode or term identity.",
+      "unknown"
+    );
+  if (liveActionIssues(entries).length)
+    return deny("condition_unresolved", "The live action projection is invalid or ambiguous.", "unknown");
+  const entry = entries.find((e) => e.action === action);
+  if (options.adcpVersion && entry && !liveActionFitsVersion(entry, options.adcpVersion))
+    return deny(
+      "condition_unresolved",
+      "The action uses metadata introduced after the supplied seller version.",
+      "unknown"
+    );
+  if (!entry)
+    return deny("not_supported_on_buy", "The seller has not made this negotiated action available now.", "unknown");
+  if (!metadataOnly && options.adcpVersion && !supportsChangeTermIdentity(options.adcpVersion))
+    return deny(
+      "condition_unresolved",
+      "The supplied seller version cannot link accepted change terms; legacy terms_ref remains opaque.",
+      "unknown"
+    );
+  if (!metadataOnly && (entry.change_term_id === void 0 || entry.change_term_id !== term.term_id))
+    return deny("condition_unresolved", "The live action does not identify its accepted change term.", "unknown");
+  if (options.termsRefIsAlias && entry.change_term_id !== void 0 && entry.terms_ref !== void 0 && entry.terms_ref !== entry.change_term_id)
+    return deny("condition_unresolved", "The deliberately emitted term aliases disagree.", "unknown");
+  if (metadataOnly && entry.change_term_id !== void 0)
+    return deny("condition_unresolved", "Metadata-only actions cannot identify a commercial change term.", "unknown");
+  if (!["self_serve", "conditional_self_serve", "seller_managed", "requires_approval"].includes(entry.mode))
+    return deny("condition_unresolved", "Unknown live action mode; refresh the seller declaration.", "unknown");
+  if (term && (entry.mode !== term.service_mode || !slaWithin(term.processing_sla, entry.sla)))
+    return deny("mode_mismatch", "The live mode or SLA exceeds the accepted commitment.");
+  if (entry.task !== void 0 && !mediaBuyActionTasks(action).includes(entry.task))
+    return deny("mode_mismatch", "The live action has no compatible canonical task.");
+  const task = entry.task ?? "update_media_buy";
+  const nonDefaultRoute = task === "update_media_buy" ? void 0 : task;
+  if (options.task !== void 0 && options.task !== "update_media_buy" && options.task !== task)
+    return deny(
+      "mode_mismatch",
+      entry.task === void 0 ? "This task-less entry uses update_media_buy. Refresh get_media_buys for a canonical task projection before changing routes." : "Use the task declared by the live action; seller_managed uses its standard async lifecycle.",
+      "blocked",
+      { nonDefaultRoute }
+    );
+  const mutations = decomposition?.mutations ?? [];
+  if (entry.applicable_package_ids !== void 0) {
+    const ids = entry.applicable_package_ids;
+    if (!Array.isArray(ids) || !ids.length || ids.some((id) => typeof id !== "string" || !id.length) || new Set(ids).size !== ids.length)
+      return deny("condition_unresolved", "Invalid live package scope.", "unknown");
+    const relevant = mutations.filter((m) => m.action === action);
+    if (!relevant.length)
+      return deny(
+        "condition_unresolved",
+        "Supply the requested packages to evaluate the live package scope.",
+        "unknown"
+      );
+    if (relevant.some((m) => m.scope !== "package" || !m.package_id || !ids.includes(m.package_id)))
+      return deny("not_supported_on_buy", "The action is not available for every requested package.");
+  }
+  let constraints;
+  if (term && (term.constraints !== void 0 || options.request)) {
+    constraints = options.request ? evaluateChangeTermConstraints(term, buy, options.request, mutations, options) : {
+      status: "unknown",
+      constraint: "request",
+      path: action,
+      message: "Supply the requested mutation to evaluate portable bounds."
+    };
+    if (constraints.status !== "satisfied")
+      return deny(
+        "condition_unresolved",
+        constraints.message,
+        constraints.status === "unknown" ? "unknown" : "blocked",
+        {
+          constraints,
+          ...constraints.status === "exceeded" && { code: "REQUOTE_REQUIRED" }
+        }
+      );
+  }
+  if (action === "add_packages" && options.request?.new_packages) {
+    const index = options.request.new_packages.findIndex(
+      (pkg) => pkg !== null && typeof pkg === "object" && ["budget", "min_spend_target", "daily_budget_cap"].some(
+        (field) => Object.hasOwn(pkg, field) && pkg[field] !== void 0
+      )
+    );
+    if (index !== -1)
+      return deny(
+        "condition_unresolved",
+        "Added-package monetary commitments cannot be assessed from package-count rights alone.",
+        "unknown",
+        {
+          constraints: {
+            status: "unknown",
+            constraint: "added_package_budget",
+            path: `new_packages[${index}]`,
+            message: "Supply a verified commercial amendment for the added package commitments; their budget baseline is not represented by this portable patch assessment."
+          }
+        }
+      );
+  }
+  return {
+    status: "available_now",
+    action,
+    mode: entry.mode,
+    nonDefaultRoute,
+    authority: metadataOnly ? "live_metadata" : "accepted_term",
+    ...term && { term },
+    entry,
+    revision: buy.revision,
+    ...constraints && { constraints }
+  };
+}
+function assessMediaBuyAction(input) {
+  const possibility = assessProductAction(input.product, input.action);
+  const promise = assessProposalAction(input.buy?.accepted_proposal ?? input.proposal, input.action);
+  const availability = assessActionAvailability(input.buy, input.action, input);
+  return { action: input.action, possibility, promise, availability };
+}
+function refreshMediaBuyActions(buy, details) {
+  if (!details || typeof details !== "object" || !("currently_available_actions" in details) || details.currently_available_actions === void 0)
+    return buy;
+  const entries = details.currently_available_actions;
+  if (liveActionIssues(entries).length) throw new TypeError("Invalid ACTION_NOT_ALLOWED action echo.");
+  return { ...buy, available_actions: structuredClone(entries) };
+}
+function preflightMediaBuyActions(buy, request, options = {}) {
+  const assessmentBuy = buy;
+  buy = withActionProposal(buy, options);
+  const shapeIssue = mutationShapeIssue(request);
+  if (shapeIssue) return { ok: false, assessments: [], message: `Invalid mutation field shape at ${shapeIssue}.` };
+  const decomposition = decomposeUpdateMediaBuy(buy, request);
+  const unresolvedField = hasUnmappedMutation(request, decomposition);
+  if (unresolvedField)
+    return {
+      ok: false,
+      assessments: [],
+      message: "At least one requested field has no supported action mapping; do not submit a partial mutation."
+    };
+  if (!decomposition.actions.length)
+    return { ok: false, assessments: [], message: "No recognized mutation could be assessed." };
+  const assessments = decomposition.actions.map(
+    ({ action }) => assessActionAvailability(assessmentBuy, action, { ...options, request })
+  );
+  if (assessments.every(
+    (a) => a.status === "available_now"
+  )) {
+    if (options.task !== "update_media_buy" && new Set(assessments.map((a) => a.nonDefaultRoute ?? "update_media_buy")).size > 1)
+      return {
+        ok: false,
+        assessments,
+        message: "The requested actions declare different compact tasks. Pass task: update_media_buy to assess the whole mutation through the compatibility facade."
+      };
+    return { ok: true, assessments };
+  }
+  return { ok: false, assessments };
+}
+export {
+  assessActionAvailability,
+  assessMediaBuyAction,
+  assessProductAction,
+  assessProposalAction,
+  preflightMediaBuyActions,
+  refreshMediaBuyActions
+};