@koda-sl/baker-cli 0.512.0 → 0.514.0

package/dist/chunk-Q3GSVLE5.js

@@ -0,0 +1,4274 @@
+import {
+  ADVANTAGE_AUDIENCE_MAX_HARD_AGE_MIN,
+  ADVANTAGE_AUDIENCE_OPEN_AGE_MAX,
+  AD_FORMATS,
+  ASSET_FEED_CTA_TYPES,
+  ATTRIBUTION_EVENT_TYPES,
+  ATTRIBUTION_MAX_WINDOW_DAYS,
+  BID_STRATEGIES,
+  BID_STRATEGIES_FORBIDDING_AMOUNT,
+  BID_STRATEGIES_REQUIRING_AMOUNT,
+  BILLING_EVENTS,
+  BUYING_TYPES,
+  CREATIVE_UPDATE_STATUSES,
+  CTA_TYPES,
+  CURRENCY_MINIMUMS,
+  CUSTOMER_FILE_SOURCES,
+  CUSTOM_AUDIENCE_SUBTYPES,
+  CUSTOM_EVENT_TYPES,
+  DEFAULT_CURRENCY_MINIMUM,
+  DESTINATION_TYPES,
+  ENROLL_STATUSES,
+  EU_DSA_COUNTRIES,
+  FREQUENCY_CAP_EVENTS,
+  FREQUENCY_CAP_TYPES,
+  IMAGE_HASH_REGEX,
+  LEAD_FORM_CTA_TYPES,
+  MEDIA_KINDS,
+  META_LIMITS,
+  NUMERIC_ID_REGEX,
+  OBJECTIVES,
+  OPTIMIZATION_GOALS,
+  OPTIMIZATION_GOALS_REQUIRING_APP,
+  OPTIMIZATION_GOALS_REQUIRING_CONVERSION_SOURCE,
+  OPTIMIZATION_GOALS_REQUIRING_PAGE,
+  OPTIMIZATION_GOALS_REQUIRING_PIXEL,
+  OPTIMIZATION_GOALS_WITH_FREQUENCY_CAP,
+  PACING_TYPES,
+  ROAS_FLOOR_SCALE,
+  SCHEDULE_TIMEZONE_TYPES,
+  SPECIAL_AD_CATEGORIES,
+  SPECIAL_CATEGORIES_REQUIRING_COUNTRY,
+  STAGEABLE_CREATE_STATUSES,
+  TEMP_REF_REGEX,
+  UPDATE_STATUSES,
+  adStudyCreateSchema,
+  adStudyUpdateSchema
+} from "./chunk-GDFJOCDO.js";
+import {
+  maskPersonValue,
+  maskedPersonValueIssue
+} from "./chunk-SOPVIIUW.js";
+
+// ../api/src/ads-meta/customConversions.ts
+var RULE_OPERATORS = {
+  eq: "is",
+  neq: "is not",
+  contains: "contains",
+  i_contains: "contains",
+  not_contains: "does not contain",
+  i_not_contains: "does not contain",
+  starts_with: "starts with",
+  i_starts_with: "starts with",
+  ends_with: "ends with",
+  i_ends_with: "ends with",
+  gt: "is more than",
+  gte: "is at least",
+  lt: "is less than",
+  lte: "is at most",
+  regex_match: "matches",
+  exists: "exists"
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var DEFAULT_CUSTOM_CONVERSION_EVENT = "PageView";
+function buildCustomConversionRule(input) {
+  return {
+    and: [
+      { event: { eq: input.event ?? DEFAULT_CUSTOM_CONVERSION_EVENT } },
+      { URL: { i_contains: input.urlContains } }
+    ]
+  };
+}
+function customConversionRuleRefusal(rule) {
+  const refusal = ruleNodeRefusal(rule, "rule");
+  if (refusal) {
+    return refusal;
+  }
+  if (!ruleFields(rule).some((field) => field !== "event")) {
+    return 'rule only names the event, and Meta refuses a custom conversion with no condition beyond it \u2014 narrow it with a URL, referrer or event parameter the event carries, e.g. {"and":[{"event":{"eq":"Lead"}},{"URL":{"i_contains":"/gracias"}}]}';
+  }
+  return void 0;
+}
+function ruleFields(node) {
+  if (!isRecord(node)) {
+    return [];
+  }
+  return Object.entries(node).flatMap(
+    ([key, value]) => (key === "and" || key === "or") && Array.isArray(value) ? value.flatMap(ruleFields) : [key]
+  );
+}
+function branchRefusal(key, value, path) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return `${path}.${key} must be a non-empty array of conditions \u2014 an empty one counts every event the pixel sends`;
+  }
+  for (const [index, child] of value.entries()) {
+    const refusal = ruleNodeRefusal(child, `${path}.${key}[${index}]`);
+    if (refusal) {
+      return refusal;
+    }
+  }
+  return void 0;
+}
+function conditionRefusal(key, value, path) {
+  return key === "and" || key === "or" ? branchRefusal(key, value, path) : leafRefusal(key, value, path);
+}
+function ruleNodeRefusal(node, path) {
+  if (!isRecord(node)) {
+    return `${path} must be an object like {"URL":{"i_contains":"/thank-you"}}`;
+  }
+  const entries = Object.entries(node);
+  if (entries.length === 0) {
+    return `${path} is empty \u2014 a rule with no condition counts every event the pixel sends`;
+  }
+  if (entries.length > 1) {
+    return `${path} names ${entries.length} conditions side by side (${entries.map(([key]) => key).join(", ")}) \u2014 Meta reads one branch or one field test per object, so combine them with {"and":[\u2026]}`;
+  }
+  for (const [key, value] of entries) {
+    const refusal = conditionRefusal(key, value, path);
+    if (refusal) {
+      return refusal;
+    }
+  }
+  return void 0;
+}
+function leafRefusal(field, condition, path) {
+  if (!isRecord(condition)) {
+    return `${path}.${field} must be a test like {"i_contains":"/thank-you"}, not a bare value`;
+  }
+  const tests = Object.entries(condition);
+  if (tests.length === 0) {
+    return `${path}.${field} names no test \u2014 use one of ${Object.keys(RULE_OPERATORS).join(", ")}`;
+  }
+  if (tests.length > 1) {
+    return `${path}.${field} names ${tests.length} operators at once (${tests.map(([operator]) => operator).join(", ")}) \u2014 test a field once per condition and combine them with {"and":[\u2026]}`;
+  }
+  for (const [operator] of tests) {
+    if (!RULE_OPERATORS[operator]) {
+      return `${path}.${field} uses "${operator}", which is not a Meta rule operator \u2014 use one of ${Object.keys(RULE_OPERATORS).join(", ")} (URL matching is i_contains, not contains or includes)`;
+    }
+  }
+  return void 0;
+}
+
+// ../api/src/ads-meta/leadAds.ts
+var META_LEAD_ADS_NOT_ENABLED_MESSAGE = "Using Meta instant forms and their leads is not switched on for this company. Everything else on Meta keeps working. Tell the user this needs switching on by the Baker team, and carry on with the rest of the job.";
+var META_LEAD_ADS_RECONNECT_MESSAGE = "This Meta connection was made before lead ads were switched on for this company, so it cannot work with instant forms or read their leads. Ask the user to reconnect Meta in the dashboard \u2014 that grants the extra permissions \u2014 then ask for this again. Everything else on Meta keeps working meanwhile.";
+function isMetaLeadAdsRefusal(message) {
+  return message === META_LEAD_ADS_NOT_ENABLED_MESSAGE || message === META_LEAD_ADS_RECONNECT_MESSAGE;
+}
+
+// ../api/src/ads-meta/placements.ts
+var FACEBOOK_POSITIONS_REQUIRING_FEED = ["marketplace", "search", "profile_feed", "notification"];
+var PLACEMENT_TARGETING_DOC = "https://developers.facebook.com/docs/marketing-api/audiences/reference/placement-targeting/";
+var PUBLISHER_PLATFORMS = ["facebook", "instagram", "threads", "messenger", "audience_network"];
+var FACEBOOK_POSITIONS = [
+  "feed",
+  "right_hand_column",
+  "marketplace",
+  "story",
+  "search",
+  "instream_video",
+  "facebook_reels",
+  "facebook_reels_overlay",
+  "profile_feed",
+  "notification"
+];
+var INSTAGRAM_POSITIONS = [
+  "stream",
+  "story",
+  "explore_home",
+  "reels",
+  "profile_feed",
+  "ig_search",
+  "profile_reels"
+];
+var AUDIENCE_NETWORK_POSITIONS = ["classic", "rewarded_video"];
+var MESSENGER_POSITIONS = ["sponsored_messages"];
+var THREADS_POSITIONS = ["threads_stream"];
+var DEVICE_PLATFORMS = ["mobile", "desktop", "connected_tv"];
+var PLACEMENT_VOCABULARIES = {
+  publisher_platforms: PUBLISHER_PLATFORMS,
+  facebook_positions: FACEBOOK_POSITIONS,
+  instagram_positions: INSTAGRAM_POSITIONS,
+  audience_network_positions: AUDIENCE_NETWORK_POSITIONS,
+  messenger_positions: MESSENGER_POSITIONS,
+  threads_positions: THREADS_POSITIONS,
+  device_platforms: DEVICE_PLATFORMS
+};
+var SAME_SURFACE_ON_THIS_PLATFORM = {
+  facebook_positions: { reels: "facebook_reels", stream: "feed", stories: "story", ig_search: "search" },
+  instagram_positions: {
+    feed: "stream",
+    facebook_reels: "reels",
+    stories: "story",
+    search: "ig_search"
+  }
+};
+var RETIRED_PLACEMENTS = {
+  facebook_positions: {
+    video_feeds: 'Meta retired Facebook video feeds \u2014 use "instream_video" for in-stream video, or "facebook_reels", and drop "video_feeds"'
+  },
+  // v26.0, re-swept 2026-10-15: `explore` is refused (subcode 2490589, "IG
+  // Explore placement is deprecated for this API version"); `explore_home`
+  // validates on its own.
+  instagram_positions: {
+    explore: 'Meta retired Instagram Explore \u2014 drop "explore"; "explore_home" (Explore home) still runs on its own'
+  },
+  // v26.0 takes Messenger `story` and silently drops it from the ad set (every
+  // version from 2026-10-27), so what was staged would never be what runs.
+  messenger_positions: {
+    story: 'Meta retired Messenger Stories \u2014 drop "story" from messenger_positions; Facebook and Instagram "story" still run'
+  }
+};
+function placementFieldsAccepting(value, except) {
+  return Object.keys(PLACEMENT_VOCABULARIES).filter(
+    (field) => field !== except && PLACEMENT_VOCABULARIES[field].includes(value)
+  );
+}
+function placementValueIssue(field, value) {
+  const retired = RETIRED_PLACEMENTS[field]?.[value];
+  if (retired) {
+    return { field, value, kind: "retired", fix: retired };
+  }
+  const renamed = SAME_SURFACE_ON_THIS_PLATFORM[field]?.[value];
+  if (renamed) {
+    return {
+      field,
+      value,
+      kind: "wrong-field",
+      fix: `Meta calls that surface "${renamed}" in ${field} \u2014 use "${renamed}"`
+    };
+  }
+  const elsewhere = placementFieldsAccepting(value, field);
+  if (elsewhere.length > 0) {
+    return {
+      field,
+      value,
+      kind: "wrong-field",
+      fix: `"${value}" belongs to ${elsewhere.join(" / ")}, not ${field} \u2014 move it there or drop it`
+    };
+  }
+  return {
+    field,
+    value,
+    kind: "unknown",
+    fix: `"${value}" is not a placement Baker knows; ${field} accepts ${PLACEMENT_VOCABULARIES[field].join(", ")}`
+  };
+}
+function invalidPlacementValues(targeting) {
+  const issues = [];
+  for (const field of Object.keys(PLACEMENT_VOCABULARIES)) {
+    const allowed = PLACEMENT_VOCABULARIES[field];
+    const selected = targeting?.[field] ?? [];
+    for (const value of selected) {
+      if (!allowed.includes(value)) {
+        issues.push(placementValueIssue(field, value));
+      }
+    }
+  }
+  return issues;
+}
+function placementCoRequirementIssues(targeting) {
+  const facebook = targeting?.facebook_positions ?? [];
+  const instagram = targeting?.instagram_positions ?? [];
+  const threads = targeting?.threads_positions ?? [];
+  const devices = targeting?.device_platforms;
+  const issues = [];
+  if (facebook.includes("story")) {
+    if (!facebook.includes("feed") && !instagram.includes("story")) {
+      issues.push(
+        'Meta refuses Facebook "story" on its own \u2014 select "feed" in facebook_positions or "story" in instagram_positions alongside it'
+      );
+    }
+    if (devices && !devices.includes("mobile")) {
+      issues.push(
+        'Facebook "story" only runs on mobile \u2014 add "mobile" to device_platforms or drop the story placement'
+      );
+    }
+  }
+  if (threads.includes("threads_stream") && !instagram.includes("stream")) {
+    issues.push('Threads "threads_stream" cannot be selected alone \u2014 add "stream" to instagram_positions');
+  }
+  return issues;
+}
+var CONSTRAINED_PLACEMENTS = [
+  {
+    position: "facebook_reels_overlay",
+    reportedAs: "facebook_reels_overlay",
+    platform: "facebook",
+    kind: "constraint",
+    note: "Ads on Facebook Reels take two shapes and a stock 9:16 video fits neither: overlay ads are 'a single, static image ad' (JPG/PNG, 1:1, 0% ratio tolerance, headline capped at 10 characters), and post-loop ads are 1:1 video of 4-15 seconds. Expect a long-headline 9:16 creative to look wrong here.",
+    contested: false,
+    source: "https://www.facebook.com/business/ads-guide/update/image/facebook-facebook-reels-overlay"
+  },
+  {
+    position: "explore_home",
+    reportedAs: "instagram_explore_grid_home",
+    platform: "instagram",
+    kind: "constraint",
+    note: "Marketing API placement asset customization states 'The explore_home placement only supports the SINGLE_IMAGE format', but Meta's own Ads Guide lists Instagram Explore home under video specs. Check the account's play rate for this position before treating it as image-only.",
+    contested: true,
+    source: "https://developers.facebook.com/docs/marketing-api/dynamic-creative/placement-asset-customization/"
+  },
+  {
+    position: "right_hand_column",
+    reportedAs: "right_hand_column",
+    platform: "facebook",
+    kind: "correction",
+    note: "Facebook right column publishes full video specs (MP4/MOV/GIF, 1:1 at 1440x1440 or mobile-only 4:5 at 1440x1800, 1 second to 241 minutes) \u2014 it is NOT image-only. Its real constraint is that it cannot be the only placement for a video, collection, or canvas ad.",
+    contested: false,
+    source: "https://www.facebook.com/business/ads-guide/update/video/facebook-right-hand-column"
+  }
+];
+var FACEBOOK_PREVIEW_FORMATS = {
+  feed: "MOBILE_FEED_STANDARD",
+  right_hand_column: "RIGHT_COLUMN_STANDARD",
+  marketplace: "MARKETPLACE_MOBILE",
+  facebook_stories: "FACEBOOK_STORY_MOBILE",
+  facebook_reels: "FACEBOOK_REELS_MOBILE",
+  facebook_reels_overlay: "FACEBOOK_REELS_BANNER",
+  instream_video: "INSTREAM_VIDEO_MOBILE",
+  // In the v25.0 ad_format enum and rendered live (2026-10-14).
+  facebook_profile_feed: "FACEBOOK_PROFILE_FEED_MOBILE",
+  // Retired for targeting (RETIRED_PLACEMENTS) and still reported by a breakdown
+  // over any window that predates the retirement — an ad set created before it
+  // keeps delivering there. Previewing what a historic row measured has to keep
+  // working, so this stays.
+  video_feeds: "INSTREAM_VIDEO_MOBILE"
+};
+var INSTAGRAM_PREVIEW_FORMATS = {
+  feed: "INSTAGRAM_STANDARD",
+  instagram_stories: "INSTAGRAM_STORY",
+  instagram_reels: "INSTAGRAM_REELS",
+  instagram_explore: "INSTAGRAM_EXPLORE_CONTEXTUAL",
+  instagram_explore_grid_home: "INSTAGRAM_EXPLORE_GRID_HOME",
+  instagram_search: "INSTAGRAM_SEARCH_CHAIN",
+  instagram_profile_feed: "INSTAGRAM_PROFILE_FEED"
+};
+var PLATFORM_SCOPED_POSITIONS = /* @__PURE__ */ new Set(["feed"]);
+function previewFormatForPosition(position, platform) {
+  if (platform === "facebook") return FACEBOOK_PREVIEW_FORMATS[position];
+  if (platform === "instagram") return INSTAGRAM_PREVIEW_FORMATS[position];
+  if (PLATFORM_SCOPED_POSITIONS.has(position)) return void 0;
+  return FACEBOOK_PREVIEW_FORMATS[position] ?? INSTAGRAM_PREVIEW_FORMATS[position];
+}
+function placementFormatNote(reportedPosition) {
+  return CONSTRAINED_PLACEMENTS.find((p) => p.reportedAs === reportedPosition);
+}
+function positionsMissingRequiredFeed(targeting) {
+  const positions = targeting?.facebook_positions;
+  if (!positions?.length || positions.includes("feed")) {
+    return [];
+  }
+  return FACEBOOK_POSITIONS_REQUIRING_FEED.filter((required) => positions.includes(required));
+}
+
+// ../api/src/ads-meta/brandSafety.ts
+import { z } from "zod";
+var publisherSchema = z.string().trim().min(3).max(2048).refine((value) => !/\s/.test(value), "a site or app address has no spaces");
+var PUBLISHER_BLOCK_LIST_MAX_URLS = 1e4;
+var publisherBlockListCreateSchema = z.strictObject({
+  name: z.string().trim().min(1).max(100),
+  /** The sites and apps to keep ads off. */
+  urls: z.array(publisherSchema).min(1).max(PUBLISHER_BLOCK_LIST_MAX_URLS)
+});
+var publisherBlockListUpdateSchema = z.strictObject({
+  /** More sites and apps to keep ads off. Meta takes none off a list. */
+  addUrls: z.array(publisherSchema).min(1).max(PUBLISHER_BLOCK_LIST_MAX_URLS).optional(),
+  status: z.literal("DELETED").optional()
+}).refine((p) => p.addUrls === void 0 !== (p.status === void 0), "add urls OR delete the list");
+var CONTENT_FILTER_LEVELS = [
+  "FACEBOOK_RELAXED",
+  "FACEBOOK_STANDARD",
+  "FACEBOOK_STRICT",
+  "AN_RELAXED",
+  "AN_STANDARD",
+  "AN_STRICT",
+  "FEED_RELAXED",
+  "FEED_STANDARD",
+  "FEED_STRICT"
+];
+var EXCLUDED_PUBLISHER_CATEGORIES = [
+  "dating",
+  "gambling",
+  "debated_social_issues",
+  "mature_audiences",
+  "tragedy_and_conflict"
+];
+var blockListRefSchema = z.union([z.string().regex(/^\d+$/), z.string().regex(TEMP_REF_REGEX)]);
+var brandSafetyTargetingFields = {
+  excluded_publisher_list_ids: z.array(blockListRefSchema).min(1).optional(),
+  brand_safety_content_filter_levels: z.array(z.enum(CONTENT_FILTER_LEVELS)).min(1).refine(
+    (levels) => new Set(levels.map((level) => level.split("_")[0])).size === levels.length,
+    "one content filter level per family (FACEBOOK, AN, FEED)"
+  ).optional(),
+  excluded_publisher_categories: z.array(z.enum(EXCLUDED_PUBLISHER_CATEGORIES)).min(1).optional()
+};
+var BRAND_SAFETY_KEYS = new Set(Object.keys(brandSafetyTargetingFields));
+
+// ../api/src/ads-meta/catalogs.ts
+import { z as z2 } from "zod";
+var tempRefSchema = z2.string().regex(TEMP_REF_REGEX, "expected a meta_temp_* reference");
+var catalogRefSchema = z2.union([z2.string().regex(NUMERIC_ID_REGEX, "expected a numeric id"), tempRefSchema]);
+var httpsUrlSchema = z2.string().url().refine((value) => value.startsWith("https://"), "must be an https URL");
+var CATALOG_LIMITS = {
+  nameMax: 100,
+  productNameMax: 200,
+  descriptionMax: 9999,
+  retailerIdMax: 100,
+  brandMax: 100,
+  additionalImagesMax: 20,
+  filterValuesMax: 500
+};
+var eventSourcesSchema = z2.array(z2.string().regex(NUMERIC_ID_REGEX)).min(1).max(10);
+var productCatalogCreateSchema = z2.strictObject({
+  name: z2.string().trim().min(1).max(CATALOG_LIMITS.nameMax),
+  /** The Business it is made on — filled at staging from the ad account's own Business; any other is refused. */
+  business_id: z2.string().regex(NUMERIC_ID_REGEX).optional(),
+  /**
+   * Pixels to connect once it exists. Advantage+ catalog ads need one: live on
+   * v26.0 a catalog ad set on a catalog without one was refused — "An event
+   * source (Facebook Pixel or App) is required to run Dynamic Ads" (1885059).
+   */
+  event_sources: eventSourcesSchema.optional()
+});
+var productCatalogUpdateSchema = z2.strictObject({
+  name: z2.string().trim().min(1).max(CATALOG_LIMITS.nameMax).optional(),
+  event_sources: eventSourcesSchema.optional(),
+  unlink_event_sources: eventSourcesSchema.optional(),
+  status: z2.literal("DELETED").optional()
+}).superRefine((p, ctx) => {
+  const changes = [p.name, p.event_sources, p.unlink_event_sources].filter((value) => value !== void 0).length;
+  if (p.status === "DELETED" && changes > 0) {
+    ctx.addIssue({ code: "custom", message: "a catalog delete changes nothing else" });
+  }
+  if (p.status === void 0 && changes === 0) {
+    ctx.addIssue({ code: "custom", message: "rename the catalog, connect or disconnect a pixel, or delete it" });
+  }
+  const both = (p.event_sources ?? []).filter((id) => p.unlink_event_sources?.includes(id));
+  if (both.length > 0) {
+    ctx.addIssue({ code: "custom", message: `pixel ${both.join(", ")} is both connected and disconnected` });
+  }
+});
+var PRODUCT_AVAILABILITIES = [
+  "in stock",
+  "out of stock",
+  "preorder",
+  "available for order",
+  "discontinued"
+];
+var PRODUCT_CONDITIONS = ["new", "refurbished", "used"];
+var priceSchema = z2.string().regex(/^\d{1,9}(\.\d{1,2})?$/, 'a price in major units, e.g. "19.99"');
+var currencySchema = z2.string().regex(/^[A-Z]{3}$/, "a three-letter currency code, e.g. EUR");
+var productFields = {
+  name: z2.string().trim().min(1).max(CATALOG_LIMITS.productNameMax),
+  description: z2.string().trim().min(1).max(CATALOG_LIMITS.descriptionMax),
+  price: priceSchema,
+  sale_price: priceSchema,
+  currency: currencySchema,
+  availability: z2.enum(PRODUCT_AVAILABILITIES),
+  condition: z2.enum(PRODUCT_CONDITIONS),
+  /** The product's own page — where its ad sends people. */
+  url: httpsUrlSchema,
+  /** A picture Meta fetches: a public https address (a library image's address works). */
+  image_url: httpsUrlSchema,
+  additional_image_urls: z2.array(httpsUrlSchema).min(1).max(CATALOG_LIMITS.additionalImagesMax),
+  brand: z2.string().trim().min(1).max(CATALOG_LIMITS.brandMax)
+};
+var productCreateSchema = z2.strictObject({
+  catalog_id: catalogRefSchema,
+  /** The advertiser's own id for the product (Meta's `retailer_id`, the SKU) — what a product set filters on. */
+  retailer_id: z2.string().trim().min(1).max(CATALOG_LIMITS.retailerIdMax),
+  name: productFields.name,
+  description: productFields.description,
+  price: productFields.price,
+  sale_price: productFields.sale_price.optional(),
+  currency: productFields.currency,
+  availability: productFields.availability.default("in stock"),
+  condition: productFields.condition.default("new"),
+  url: productFields.url,
+  image_url: productFields.image_url,
+  additional_image_urls: productFields.additional_image_urls.optional(),
+  brand: productFields.brand.optional()
+});
+var productUpdateSchema = z2.strictObject({
+  name: productFields.name.optional(),
+  description: productFields.description.optional(),
+  price: productFields.price.optional(),
+  sale_price: productFields.sale_price.optional(),
+  currency: productFields.currency.optional(),
+  availability: productFields.availability.optional(),
+  condition: productFields.condition.optional(),
+  url: productFields.url.optional(),
+  image_url: productFields.image_url.optional(),
+  additional_image_urls: productFields.additional_image_urls.optional(),
+  brand: productFields.brand.optional(),
+  status: z2.literal("DELETED").optional()
+}).superRefine((p, ctx) => {
+  const changes = Object.keys(p).filter((key) => key !== "status");
+  if (p.status === "DELETED" && changes.length > 0) {
+    ctx.addIssue({ code: "custom", message: "a product delete changes nothing else" });
+  }
+  if (p.status === void 0 && changes.length === 0) {
+    ctx.addIssue({ code: "custom", message: "change at least one field, or delete the product" });
+  }
+  if ((p.price !== void 0 || p.sale_price !== void 0) && p.currency === void 0) {
+    ctx.addIssue({ code: "custom", path: ["currency"], message: "a price names its currency" });
+  }
+});
+var LIST_OPERATORS = ["is_any", "is_not_any"];
+var NUMBER_OPERATORS = ["lt", "lte", "gt", "gte"];
+var TEXT_OPERATORS = [
+  "eq",
+  "neq",
+  "contains",
+  "not_contains",
+  "i_contains",
+  "i_not_contains",
+  "starts_with"
+];
+var PRODUCT_SET_OPERATORS = [...LIST_OPERATORS, ...NUMBER_OPERATORS, ...TEXT_OPERATORS];
+var conditionSchema = z2.union([
+  ...LIST_OPERATORS.map(
+    (operator) => z2.strictObject({ [operator]: z2.array(z2.string().min(1)).min(1).max(CATALOG_LIMITS.filterValuesMax) })
+  ),
+  ...NUMBER_OPERATORS.map((operator) => z2.strictObject({ [operator]: z2.number() })),
+  ...TEXT_OPERATORS.map((operator) => z2.strictObject({ [operator]: z2.string().min(1) }))
+]);
+var FIELD_NAME_REGEX = /^[a-z][a-z0-9_.]*$/;
+function productSetFilterIssue(rule) {
+  if (!rule || typeof rule !== "object" || Array.isArray(rule)) return "a rule is an object";
+  const entries = Object.entries(rule);
+  if (entries.length !== 1) return "one field per rule \u2014 combine several with and / or";
+  const [key, value] = entries[0];
+  if (key === "and" || key === "or") {
+    if (!Array.isArray(value) || value.length === 0) return `${key} takes a list of rules`;
+    for (const inner of value) {
+      const issue = productSetFilterIssue(inner);
+      if (issue) return issue;
+    }
+    return void 0;
+  }
+  if (!FIELD_NAME_REGEX.test(key)) {
+    return "a rule names a product field, e.g. retailer_id, brand, product_type, price, custom_label_0";
+  }
+  return conditionSchema.safeParse(value).success ? void 0 : `${key}: one operator of ${PRODUCT_SET_OPERATORS.join(", ")} with its value \u2014 a list for is_any / is_not_any, a number for lt / lte / gt / gte, text for the rest`;
+}
+var productSetFilterSchema = z2.record(z2.string(), z2.unknown()).superRefine((rule, ctx) => {
+  const issue = productSetFilterIssue(rule);
+  if (issue) ctx.addIssue({ code: "custom", message: issue });
+}).transform((rule) => rule);
+var productSetCreateSchema = z2.strictObject({
+  catalog_id: catalogRefSchema,
+  name: z2.string().trim().min(1).max(CATALOG_LIMITS.nameMax),
+  /** Which products are in it. Without one the set holds the whole catalog. */
+  filter: productSetFilterSchema.optional()
+});
+var productSetUpdateSchema = z2.strictObject({
+  name: z2.string().trim().min(1).max(CATALOG_LIMITS.nameMax).optional(),
+  filter: productSetFilterSchema.optional(),
+  status: z2.literal("DELETED").optional()
+}).superRefine((p, ctx) => {
+  const changes = p.name !== void 0 || p.filter !== void 0;
+  if (p.status === "DELETED" && changes) {
+    ctx.addIssue({ code: "custom", message: "a product set delete changes nothing else" });
+  }
+  if (p.status === void 0 && !changes) {
+    ctx.addIssue({ code: "custom", message: "rename the set, change its filter, or delete it" });
+  }
+});
+function retailerIdFilter(retailerIds) {
+  return { retailer_id: { is_any: [...retailerIds] } };
+}
+var FEED_INTERVALS = ["HOURLY", "DAILY", "WEEKLY"];
+var FEED_DAYS = ["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"];
+var feedScheduleSchema = z2.strictObject({
+  url: httpsUrlSchema,
+  interval: z2.enum(FEED_INTERVALS),
+  /** Hour of day, 0–23, in Meta's feed time zone. */
+  hour: z2.number().int().min(0).max(23).optional(),
+  day_of_week: z2.enum(FEED_DAYS).optional()
+}).superRefine((s, ctx) => {
+  if (s.interval === "WEEKLY" && s.day_of_week === void 0) {
+    ctx.addIssue({ code: "custom", path: ["day_of_week"], message: "a weekly schedule names its day" });
+  }
+  if (s.interval !== "WEEKLY" && s.day_of_week !== void 0) {
+    ctx.addIssue({ code: "custom", path: ["day_of_week"], message: "only a weekly schedule names a day" });
+  }
+});
+var productFeedCreateSchema = z2.strictObject({
+  catalog_id: catalogRefSchema,
+  name: z2.string().trim().min(1).max(CATALOG_LIMITS.nameMax),
+  /** Without one the feed waits for files uploaded to it. */
+  schedule: feedScheduleSchema.optional()
+});
+var productFeedUpdateSchema = z2.strictObject({
+  name: z2.string().trim().min(1).max(CATALOG_LIMITS.nameMax).optional(),
+  schedule: feedScheduleSchema.optional(),
+  status: z2.literal("DELETED").optional()
+}).superRefine((p, ctx) => {
+  const changes = p.name !== void 0 || p.schedule !== void 0;
+  if (p.status === "DELETED" && changes) {
+    ctx.addIssue({ code: "custom", message: "a feed delete changes nothing else" });
+  }
+  if (p.status === void 0 && !changes) {
+    ctx.addIssue({ code: "custom", message: "rename the feed, change its schedule, or delete it" });
+  }
+});
+
+// ../api/src/ads-meta/customerList.ts
+import { z as z3 } from "zod";
+var CUSTOMER_LIST_KEYS = [
+  "EMAIL",
+  "PHONE",
+  "FN",
+  "LN",
+  "FI",
+  "CT",
+  "ST",
+  "ZIP",
+  "COUNTRY",
+  "DOBY",
+  "DOBM",
+  "DOBD",
+  "GEN",
+  "MADID",
+  "EXTERN_ID",
+  "LOOKALIKE_VALUE"
+];
+var UNHASHED_CUSTOMER_LIST_KEYS = /* @__PURE__ */ new Set([
+  "MADID",
+  "EXTERN_ID",
+  "LOOKALIKE_VALUE"
+]);
+var IDENTIFYING_CUSTOMER_LIST_KEYS = ["EMAIL", "PHONE", "MADID", "EXTERN_ID"];
+var CUSTOMER_LIST_BATCH_ROWS = 1e4;
+var CUSTOMER_LIST_MAX_BATCHES = 20;
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+var MADID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function customerListCellIssue(key, value) {
+  if (value === "") {
+    return key === "LOOKALIKE_VALUE" ? "a value-based list carries a value for every person \u2014 give the row a value or leave it out" : void 0;
+  }
+  if (key === "LOOKALIKE_VALUE") {
+    return /^\d+(\.\d+)?$/.test(value) ? void 0 : "a value-based list carries a number of 0 or more per person";
+  }
+  if (key === "MADID") {
+    return MADID.test(value) ? void 0 : "a mobile advertiser id is a lowercase IDFA/AAID with hyphens";
+  }
+  if (key === "EXTERN_ID") {
+    return value.length <= 256 ? void 0 : "an external id is at most 256 characters";
+  }
+  return SHA256_HEX.test(value) ? void 0 : `${key} must be the lowercase SHA-256 digest the CLI makes from the normalized value, never the value itself`;
+}
+var PREVIEW_KIND = {
+  EMAIL: "email",
+  PHONE: "phone",
+  FN: "name",
+  LN: "name",
+  FI: "hidden",
+  CT: "name",
+  ST: "shown",
+  ZIP: "name",
+  COUNTRY: "country",
+  DOBY: "hidden",
+  DOBM: "hidden",
+  DOBD: "hidden",
+  GEN: "shown",
+  MADID: "id",
+  EXTERN_ID: "shown",
+  LOOKALIKE_VALUE: "shown"
+};
+function customerListPreviewCell(key, normalized) {
+  return maskPersonValue(PREVIEW_KIND[key], normalized);
+}
+function customerListPreviewIssue(key, preview) {
+  return maskedPersonValueIssue(PREVIEW_KIND[key], preview) && `the preview of ${key} must be masked the way the CLI masks it, never the value itself`;
+}
+function previewsIssue(batch) {
+  if (!batch.previews) return void 0;
+  if (batch.previews.length !== batch.rows.length) return { path: ["previews"], message: "one preview per row" };
+  for (const [index, preview] of batch.previews.entries()) {
+    const message = preview.length === batch.schema.length ? batch.schema.map((key, column) => customerListPreviewIssue(key, preview[column] ?? "")).find(Boolean) : `each preview has one value per column (${batch.schema.length})`;
+    if (message) return { path: ["previews", index], message };
+  }
+  return void 0;
+}
+var schemaColumnsSchema = z3.array(z3.enum(CUSTOMER_LIST_KEYS)).min(1).refine((keys) => new Set(keys).size === keys.length, "each column appears once").refine(
+  (keys) => keys.some((key) => IDENTIFYING_CUSTOMER_LIST_KEYS.includes(key)),
+  `a customer list matches people on at least one of ${IDENTIFYING_CUSTOMER_LIST_KEYS.join(", ")}`
+);
+var customerListBatchSchema = z3.strictObject({
+  schema: schemaColumnsSchema,
+  rows: z3.array(z3.array(z3.string())).min(1).max(CUSTOMER_LIST_BATCH_ROWS),
+  /** Each row's person masked for the review (`customerListPreviewCell`), in the rows' order. Older CLIs send none. */
+  previews: z3.array(z3.array(z3.string())).optional()
+}).superRefine((batch, ctx) => {
+  const previews = previewsIssue(batch);
+  if (previews) {
+    ctx.addIssue({ code: "custom", path: previews.path, message: previews.message });
+    return;
+  }
+  for (const [index, row] of batch.rows.entries()) {
+    if (row.length !== batch.schema.length) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["rows", index],
+        message: `each row has one value per column (${batch.schema.length})`
+      });
+      return;
+    }
+    for (const [column, key] of batch.schema.entries()) {
+      const issue = customerListCellIssue(key, row[column] ?? "");
+      if (issue) {
+        ctx.addIssue({ code: "custom", path: ["rows", index, column], message: issue });
+        return;
+      }
+    }
+  }
+});
+var customerListBatchResponseSchema = z3.object({ fileId: z3.string(), rows: z3.number().int() });
+var CUSTOMER_LIST_ACTIONS = ["add", "remove", "replace"];
+var customAudienceMembersSchema = z3.strictObject({
+  audience_id: z3.union([z3.string().regex(NUMERIC_ID_REGEX), z3.string().regex(TEMP_REF_REGEX)]),
+  action: z3.enum(CUSTOMER_LIST_ACTIONS),
+  schema: schemaColumnsSchema,
+  batches: z3.array(z3.strictObject({ fileId: z3.string().min(1), rows: z3.number().int().min(1).max(CUSTOMER_LIST_BATCH_ROWS) })).min(1).max(CUSTOMER_LIST_MAX_BATCHES)
+}).superRefine((p, ctx) => {
+  if (new Set(p.batches.map((batch) => batch.fileId)).size !== p.batches.length) {
+    ctx.addIssue({ code: "custom", path: ["batches"], message: "each batch is sent once" });
+  }
+});
+
+// ../api/src/ads-meta/ops.ts
+import { z as z12 } from "zod";
+
+// ../api/src/ads-meta/adRules.ts
+import { z as z4 } from "zod";
+var AD_RULE_EVALUATION_TYPES = ["SCHEDULE", "TRIGGER"];
+var AD_RULE_OPERATORS = [
+  "GREATER_THAN",
+  "LESS_THAN",
+  "EQUAL",
+  "NOT_EQUAL",
+  "IN_RANGE",
+  "NOT_IN_RANGE",
+  "IN",
+  "NOT_IN",
+  "CONTAIN",
+  "NOT_CONTAIN",
+  "ANY",
+  "ALL",
+  "NONE"
+];
+var AD_RULE_TRIGGER_TYPES = [
+  "METADATA_CREATION",
+  "METADATA_UPDATE",
+  "STATS_MILESTONE",
+  "STATS_CHANGE",
+  "DELIVERY_INSIGHTS_CHANGE"
+];
+var AD_RULE_EXECUTION_TYPES = [
+  "PAUSE",
+  "UNPAUSE",
+  "NOTIFICATION",
+  "CHANGE_BUDGET",
+  "CHANGE_CAMPAIGN_BUDGET",
+  "CHANGE_BID",
+  "ROTATE",
+  "REBALANCE_BUDGET"
+];
+var TRIGGER_EXECUTION_TYPES = /* @__PURE__ */ new Set(["PAUSE", "UNPAUSE", "NOTIFICATION"]);
+var AD_RULE_SCHEDULE_TYPES = ["DAILY", "HOURLY", "SEMI_HOURLY", "CUSTOM"];
+var AD_RULE_CREATE_STATUSES = ["ENABLED", "DISABLED"];
+var AD_RULE_UPDATE_STATUSES = ["ENABLED", "DISABLED", "DELETED"];
+var AD_RULE_ENTITY_TYPES = ["AD", "ADSET", "CAMPAIGN"];
+var TIME_PRESETS_WITH_TODAY = [
+  "LIFETIME",
+  "TODAY",
+  "LAST_2_DAYS",
+  "LAST_3_DAYS",
+  "LAST_7_DAYS",
+  "LAST_14_DAYS",
+  "LAST_28_DAYS",
+  "LAST_30_DAYS",
+  "THIS_MONTH",
+  "THIS_WEEK_MON_TODAY",
+  "THIS_WEEK_SUN_TODAY"
+];
+var AD_RULE_TIME_PRESETS = [
+  ...TIME_PRESETS_WITH_TODAY,
+  "YESTERDAY",
+  "LAST_2D",
+  "LAST_3D",
+  "LAST_7D",
+  "LAST_14D",
+  "LAST_28D",
+  "LAST_30D",
+  "LAST_ND_14_8",
+  "LAST_ND_30_8",
+  "LAST_ND_60_8",
+  "LAST_ND_120_8",
+  "LAST_ND_180_8",
+  "LAST_ND_LIFETIME_8",
+  "LAST_ND_60_29",
+  "LAST_ND_120_29",
+  "LAST_ND_180_29",
+  "LAST_ND_LIFETIME_29"
+];
+var SPECIAL_FIELDS = ["entity_type", "time_preset", "attribution_window", "aggregation_id"];
+var METADATA_FIELDS = [
+  "id",
+  "name",
+  "adlabel_ids",
+  "objective",
+  "start_time",
+  "stop_time",
+  "buying_type",
+  "billing_event",
+  "optimization_goal",
+  "is_autobid",
+  "daily_budget",
+  "lifetime_budget",
+  "spend_cap",
+  "bid_amount",
+  "created_time",
+  "updated_time"
+];
+var SCHEDULE_ONLY_METADATA_FIELDS = [
+  "effective_status",
+  "placement.page_types",
+  "budget_reset_period",
+  "hours_since_creation",
+  "estimated_budget_spending_percentage",
+  "audience_reached_percentage",
+  "active_time",
+  "current_time"
+];
+var APP_EVENTS = [
+  "achievement_unlocked",
+  "activate_app",
+  "add_payment_info",
+  "add_to_cart",
+  "add_to_wishlist",
+  "complete_registration",
+  "content_view",
+  "initiated_checkout",
+  "level_achieved",
+  "purchase",
+  "rate",
+  "search",
+  "spent_credits",
+  "tutorial_completion"
+];
+var OFFLINE_EVENTS = [
+  "add_payment_info",
+  "add_to_cart",
+  "add_to_wishlist",
+  "complete_registration",
+  "initiate_checkout",
+  "lead",
+  "other",
+  "purchase",
+  "search",
+  "view_content"
+];
+var PIXEL_EVENTS = [
+  "add_payment_info",
+  "add_to_cart",
+  "add_to_wishlist",
+  "complete_registration",
+  "initiate_checkout",
+  "lead",
+  "purchase",
+  "search",
+  "view_content",
+  "other"
+];
+var PIXEL_COST_EVENTS = [
+  "add_payment_info",
+  "add_to_cart",
+  "add_to_wishlist",
+  "complete_registration",
+  "initiate_checkout",
+  "lead",
+  "purchase",
+  "search",
+  "view_content"
+];
+var SCHEDULE_ONLY_INSIGHTS_FIELDS = [
+  "mobile_app_purchase_roas",
+  "website_purchase_roas",
+  "offline_conversion",
+  ...OFFLINE_EVENTS.map((event) => `offline_conversion.${event}`),
+  "cost_per_offline_conversion",
+  "cost_per_offline_other",
+  "cost_per_post_engagement",
+  "lifetime_impressions",
+  "lifetime_spent",
+  "today_spent",
+  "yesterday_spent",
+  // The same page lists both as "Yes" higher up and "No" in its last rows; the
+  // stricter reading is kept, since a refused real-time rule fails at publish.
+  "unique_clicks",
+  "reach"
+];
+var INSIGHTS_FIELDS = /* @__PURE__ */ new Set([
+  ...SCHEDULE_ONLY_INSIGHTS_FIELDS,
+  "impressions",
+  "unique_impressions",
+  "clicks",
+  "unique_clicks",
+  "spent",
+  "results",
+  "cost_per",
+  "cpc",
+  "cpm",
+  "ctr",
+  "cpa",
+  "cpp",
+  "reach",
+  "frequency",
+  "leadgen",
+  "link_ctr",
+  "cost_per_unique_click",
+  "result_rate",
+  "mobile_app_install",
+  "cost_per_mobile_app_install",
+  "app_custom_event",
+  ...APP_EVENTS.map((event) => `app_custom_event.fb_mobile_${event}`),
+  "app_custom_event.other",
+  ...APP_EVENTS.map((event) => `cost_per_mobile_${event}`),
+  "offsite_conversion",
+  ...PIXEL_EVENTS.map((event) => `offsite_conversion.fb_pixel_${event}`),
+  ...PIXEL_COST_EVENTS.map((event) => `cost_per_${event}_fb`),
+  "link_click",
+  "cost_per_link_click",
+  "like",
+  "offsite_engagement",
+  "post",
+  "post_comment",
+  "post_engagement",
+  "post_like",
+  "post_reaction",
+  "view_content",
+  "video_play",
+  "video_view",
+  "vote"
+]);
+var ADVANCED_FIELDS = /* @__PURE__ */ new Set(["daily_ratio_spent", "lifetime_ratio_spent"]);
+var OBJECT_PREFIXES = ["ad", "adset", "campaign"];
+var ATTRIBUTION_PREFIXES = [
+  "account_default",
+  "default",
+  "inline",
+  "1d_view",
+  "7d_view",
+  "28d_view",
+  "1d_click",
+  "7d_click",
+  "28d_click",
+  "1d_view_1d_click",
+  "7d_view_1d_click",
+  "28d_view_1d_click",
+  "1d_view_7d_click",
+  "7d_view_7d_click",
+  "28d_view_7d_click",
+  "7d_view_28d_click",
+  "28d_view_28d_click"
+];
+var LIVE_ATTRIBUTION_PREFIX = "account_default";
+var AD_RULE_ATTRIBUTION_WINDOWS = [LIVE_ATTRIBUTION_PREFIX.toUpperCase()];
+var RETIRED_ATTRIBUTION = `Meta retired every attribution window in rules but the account's own (#11 "This attribution window has been deprecated") \u2014 leave the window out, or use ACCOUNT_DEFAULT (account_default:)`;
+function retiredAttributionPrefix(field) {
+  const colon = field.indexOf(":");
+  const prefix = colon > 0 ? field.slice(0, colon) : void 0;
+  return prefix !== void 0 && prefix !== LIVE_ATTRIBUTION_PREFIX && ATTRIBUTION_PREFIXES.includes(prefix);
+}
+var TIME_PREFIXES = AD_RULE_TIME_PRESETS.map((preset) => `${preset.toLowerCase()}_`).sort(
+  (a, b) => b.length - a.length
+);
+var KNOWN_PLAIN_FIELDS = /* @__PURE__ */ new Set([
+  ...SPECIAL_FIELDS,
+  ...METADATA_FIELDS,
+  ...SCHEDULE_ONLY_METADATA_FIELDS,
+  ...INSIGHTS_FIELDS,
+  ...ADVANCED_FIELDS
+]);
+function plainKind(field) {
+  if (SPECIAL_FIELDS.includes(field)) return "special";
+  if (INSIGHTS_FIELDS.has(field)) return "insights";
+  if (ADVANCED_FIELDS.has(field)) return "advanced";
+  if (KNOWN_PLAIN_FIELDS.has(field)) return "metadata";
+  return void 0;
+}
+function insightsBase(field) {
+  let rest = field;
+  const colon = rest.indexOf(":");
+  if (colon > 0) {
+    if (!ATTRIBUTION_PREFIXES.includes(rest.slice(0, colon))) return void 0;
+    rest = rest.slice(colon + 1);
+  }
+  if (INSIGHTS_FIELDS.has(rest)) return rest;
+  const prefix = TIME_PREFIXES.find((candidate) => rest.startsWith(candidate));
+  const base = prefix ? rest.slice(prefix.length) : void 0;
+  return base && INSIGHTS_FIELDS.has(base) ? base : void 0;
+}
+function singleField(field) {
+  const kind = plainKind(field);
+  if (kind) return { kind, base: field };
+  const aggregate = /^aggregate\((.+)\)$/.exec(field);
+  if (aggregate?.[1]) {
+    const base2 = insightsBase(aggregate[1]);
+    return base2 ? { kind: "aggregate", base: base2 } : void 0;
+  }
+  const dot = field.indexOf(".");
+  const object = dot > 0 ? OBJECT_PREFIXES.find((prefix) => prefix === field.slice(0, dot)) : void 0;
+  const rest = object ? field.slice(dot + 1) : field;
+  const restKind = object ? plainKind(rest) : void 0;
+  if (object && restKind && restKind !== "special") return { kind: restKind, base: rest, object };
+  const base = insightsBase(rest);
+  return base ? { kind: "insights", base, ...object ? { object } : {} } : void 0;
+}
+var FORMULA_OPERATORS = /* @__PURE__ */ new Set(["+", "-", "*", "/"]);
+var MAX_FORMULA_FIELDS = 6;
+function formulaTerms(field) {
+  const tokens = field.trim().split(/\s+/);
+  const fields = [];
+  for (const [index, token] of tokens.entries()) {
+    const isOperator = FORMULA_OPERATORS.has(token);
+    if (index % 2 === 1 ? !isOperator : isOperator) {
+      return { refusal: `formula "${field}" must alternate terms and + - * / operators, each separated by a space` };
+    }
+    if (!isOperator && !/^-?\d+(\.\d+)?$/.test(token)) fields.push(token);
+  }
+  if (tokens.length % 2 === 0) return { refusal: `formula "${field}" ends with an operator` };
+  if (fields.length > MAX_FORMULA_FIELDS) {
+    return { refusal: `formula "${field}" uses ${fields.length} fields; Meta allows at most ${MAX_FORMULA_FIELDS}` };
+  }
+  return { fields };
+}
+var FIELD_HELP = "see the field list in `baker schema ads.meta.rules.create` (Insights metrics like cost_per, spent, results, cpm, ctr, frequency, website_purchase_roas; metadata like name, daily_budget, hours_since_creation), optionally prefixed by ad./adset./campaign., the account's attribution window (account_default:) or a time range (yesterday_)";
+function parseAdRuleField(field) {
+  const retired = field.split(/[\s()]+/).map((term) => term.replace(/^(ad|adset|campaign)\./, "")).find(retiredAttributionPrefix);
+  if (retired) return { refusal: `"${field}": ${RETIRED_ATTRIBUTION}` };
+  if (!/\s/.test(field.trim())) {
+    return singleField(field) ?? { refusal: `Meta does not recognise the filter field "${field}" \u2014 ${FIELD_HELP}` };
+  }
+  const terms = formulaTerms(field);
+  if ("refusal" in terms) return terms;
+  const unknown = terms.fields.find((term) => {
+    const parsed = singleField(term);
+    return !parsed || parsed.kind === "special";
+  });
+  if (unknown) {
+    return { refusal: `formula "${field}": Meta does not recognise the field "${unknown}" \u2014 ${FIELD_HELP}` };
+  }
+  return formulaAmountRefusal(field, terms.fields) ?? { kind: "formula", base: field };
+}
+function formulaAmountRefusal(field, fields) {
+  const amounts = fields.filter((term) => isAdRuleMoneyField(term));
+  if (amounts.length === 0) return void 0;
+  const ratioOfAmounts = fields.length === 2 && amounts.length === 2 && field.trim().split(/\s+/)[1] === "/";
+  return ratioOfAmounts ? void 0 : {
+    refusal: `formula "${field}" works out to an amount, which Meta compares in the account's minor units and Baker cannot convert inside a formula \u2014 use a plain cost field (cost_per, cpa, cpc) or a ratio of two amounts`
+  };
+}
+var COST_BASES = /* @__PURE__ */ new Set(["cpa", "cpc", "cpm", "cpp", "cost_per"]);
+function isCostField(field) {
+  const parsed = parseAdRuleField(field);
+  return "kind" in parsed && parsed.kind !== "formula" && (COST_BASES.has(parsed.base) || parsed.base.startsWith("cost_per"));
+}
+function isInsightsField(field) {
+  const parsed = parseAdRuleField(field);
+  return "kind" in parsed && parsed.kind !== "special" && parsed.kind !== "metadata";
+}
+var scalarSchema = z4.union([z4.number(), z4.string(), z4.boolean()]);
+var adRuleFilterSchema = z4.strictObject({
+  field: z4.string().min(1),
+  operator: z4.enum(AD_RULE_OPERATORS),
+  value: z4.union([scalarSchema, z4.array(scalarSchema)])
+});
+var triggerSchema = z4.strictObject({
+  type: z4.enum(AD_RULE_TRIGGER_TYPES),
+  field: z4.string().min(1).optional(),
+  operator: z4.enum(AD_RULE_OPERATORS).optional(),
+  value: z4.union([scalarSchema, z4.array(scalarSchema)]).optional()
+});
+var adRuleEvaluationSpecSchema = z4.strictObject({
+  evaluation_type: z4.enum(AD_RULE_EVALUATION_TYPES),
+  filters: z4.array(adRuleFilterSchema).min(1),
+  trigger: triggerSchema.optional()
+});
+var executionOptionSchema = z4.strictObject({
+  field: z4.string().min(1),
+  operator: z4.enum(["EQUAL", "IN"]).default("EQUAL"),
+  value: z4.unknown()
+});
+var adRuleExecutionSpecSchema = z4.strictObject({
+  execution_type: z4.enum(AD_RULE_EXECUTION_TYPES),
+  execution_options: z4.array(executionOptionSchema).optional()
+});
+var scheduleItemSchema = z4.strictObject({
+  start_minute: z4.number().int().optional(),
+  end_minute: z4.number().int().optional(),
+  days: z4.array(z4.number().int()).optional()
+});
+var adRuleScheduleSpecSchema = z4.strictObject({
+  schedule_type: z4.enum(AD_RULE_SCHEDULE_TYPES),
+  schedule: z4.array(scheduleItemSchema).optional()
+});
+var COMPARE = ["GREATER_THAN", "LESS_THAN", "EQUAL", "IN_RANGE", "NOT_IN_RANGE"];
+var BOUNDED = ["GREATER_THAN", "LESS_THAN", "IN_RANGE", "NOT_IN_RANGE"];
+var LISTED = ["IN", "NOT_IN"];
+var TAGGED = ["ANY", "ALL", "NONE"];
+var METADATA_OPERATORS = {
+  id: ["EQUAL", "IN", "NOT_IN"],
+  name: ["EQUAL", "CONTAIN", "NOT_CONTAIN"],
+  adlabel_ids: TAGGED,
+  objective: LISTED,
+  buying_type: LISTED,
+  billing_event: LISTED,
+  optimization_goal: LISTED,
+  is_autobid: LISTED,
+  effective_status: LISTED,
+  budget_reset_period: LISTED,
+  "placement.page_types": TAGGED,
+  stop_time: ["GREATER_THAN", "LESS_THAN"]
+};
+var SPECIAL_OPERATORS = {
+  entity_type: ["EQUAL"],
+  time_preset: ["EQUAL"],
+  attribution_window: ["EQUAL"],
+  aggregation_id: ["IN"]
+};
+function operatorsFor(parsed) {
+  if (parsed.kind === "special") return SPECIAL_OPERATORS[parsed.base] ?? ["EQUAL"];
+  if (parsed.kind === "metadata") return METADATA_OPERATORS[parsed.base] ?? BOUNDED;
+  return COMPARE;
+}
+function isAscendingPair(value) {
+  return Array.isArray(value) && value.length === 2 && value.every((bound) => typeof bound === "number") && value[0] < value[1];
+}
+var isNonEmptyList = (value) => Array.isArray(value) && value.length > 0;
+var isText = (value) => typeof value === "string" && value.length > 0;
+var VALUE_SHAPES = {
+  IN_RANGE: { fits: isAscendingPair, words: "a [low, high] pair of numbers, low first" },
+  NOT_IN_RANGE: { fits: isAscendingPair, words: "a [low, high] pair of numbers, low first" },
+  IN: { fits: isNonEmptyList, words: "a non-empty list" },
+  NOT_IN: { fits: isNonEmptyList, words: "a non-empty list" },
+  ANY: { fits: isNonEmptyList, words: "a non-empty list" },
+  ALL: { fits: isNonEmptyList, words: "a non-empty list" },
+  NONE: { fits: isNonEmptyList, words: "a non-empty list" },
+  CONTAIN: { fits: isText, words: "text" },
+  NOT_CONTAIN: { fits: isText, words: "text" }
+};
+function valueShapeIssue(operator, value, textual) {
+  const shape = VALUE_SHAPES[operator] ?? {
+    fits: (candidate) => typeof candidate === "number" || textual && typeof candidate === "string",
+    words: textual ? "text" : "a number"
+  };
+  return shape.fits(value) ? void 0 : `${operator} takes ${shape.words}`;
+}
+var TEXTUAL_FIELDS = /* @__PURE__ */ new Set(["name", "id", "entity_type", "time_preset", "attribution_window"]);
+var ENUM_VALUES = {
+  entity_type: AD_RULE_ENTITY_TYPES,
+  time_preset: AD_RULE_TIME_PRESETS,
+  attribution_window: AD_RULE_ATTRIBUTION_WINDOWS
+};
+function enumIssue(parsed, value) {
+  const allowed = parsed.kind === "special" ? ENUM_VALUES[parsed.base] : void 0;
+  if (!allowed || typeof value === "string" && allowed.includes(value)) return void 0;
+  return `${parsed.base} must be one of ${allowed.join(", ")}`;
+}
+function oneFilterIssue(filter) {
+  const parsed = parseAdRuleField(filter.field);
+  if ("refusal" in parsed) return parsed.refusal;
+  const operators = operatorsFor(parsed);
+  if (!operators.includes(filter.operator)) {
+    return `${filter.field} takes ${operators.join(", ")} \u2014 not ${filter.operator}`;
+  }
+  return valueShapeIssue(filter.operator, filter.value, TEXTUAL_FIELDS.has(parsed.base)) ?? enumIssue(parsed, filter.value);
+}
+function filtersNamed(spec, field) {
+  return spec.filters.filter((filter) => filter.field === field);
+}
+function scopeIssues(spec) {
+  if (filtersNamed(spec, "entity_type").length > 0 || filtersNamed(spec, "id").length > 0) return [];
+  return [
+    {
+      path: ["evaluation_spec", "filters"],
+      message: "say what the rule applies to \u2014 add an entity_type filter (EQUAL AD, ADSET or CAMPAIGN) or an id filter (IN [ids])"
+    }
+  ];
+}
+function onceOnly(spec, field) {
+  return filtersNamed(spec, field).length > 1 ? [{ path: ["evaluation_spec", "filters"], message: `Meta takes one ${field} filter per rule` }] : [];
+}
+function measuresPerformance(spec) {
+  return spec.filters.some((filter) => isInsightsField(filter.field)) || spec.trigger?.type.startsWith("STATS") === true;
+}
+function timePresetIssues(spec) {
+  if (!measuresPerformance(spec) || filtersNamed(spec, "time_preset").length > 0) return [];
+  return [
+    {
+      path: ["evaluation_spec", "filters"],
+      message: "a performance condition needs a time range \u2014 add a time_preset filter (EQUAL, e.g. LAST_7D); Meta refuses the rule without one"
+    }
+  ];
+}
+function aggregateIssues(spec) {
+  const aggregates = spec.filters.some((filter) => filter.field.startsWith("aggregate("));
+  if (!aggregates || filtersNamed(spec, "aggregation_id").length > 0) return [];
+  return [
+    {
+      path: ["evaluation_spec", "filters"],
+      message: "an aggregate(...) filter needs an aggregation_id filter (IN [ids]) naming what to add up"
+    }
+  ];
+}
+var TEMP_REF = /^meta_temp_[A-Za-z0-9_-]{4,}$/;
+var NUMERIC_ID = /^\d+$/;
+var ENTITY_OF_PREFIX = {
+  "ad.id": "ad",
+  "adset.id": "adSet",
+  "campaign.id": "campaign"
+};
+function idFilterEntity(field) {
+  if (field === "id") return "level";
+  if (/(^|\.)adlabel_ids$/.test(field)) return "adLabel";
+  return ENTITY_OF_PREFIX[field];
+}
+function idValues(value) {
+  return (Array.isArray(value) ? value : [value]).map(String);
+}
+function idFilterIssue(filter, level) {
+  const named = idFilterEntity(filter.field);
+  const ids = filter.field === "aggregation_id" || named ? idValues(filter.value) : [];
+  const bad = ids.find((id) => !NUMERIC_ID.test(id) && !TEMP_REF.test(id));
+  if (bad) return `${filter.field} takes bare numeric ids or meta_temp_* refs \u2014 not "${bad}"`;
+  const temp = ids.some((id) => TEMP_REF.test(id));
+  if (temp && filter.field === "aggregation_id")
+    return "aggregation_id takes ids already on Meta, not meta_temp_* refs";
+  if (temp && named === "level" && !level) {
+    return "an id filter naming meta_temp_* refs needs an entity_type filter too, so the rule waits for the right objects";
+  }
+  return void 0;
+}
+function filterIssues(spec) {
+  const issues = [];
+  const level = adRuleLevel(spec);
+  for (const [index, filter] of spec.filters.entries()) {
+    const message = oneFilterIssue(filter) ?? idFilterIssue(filter, level);
+    if (message) issues.push({ path: ["evaluation_spec", "filters", index], message });
+  }
+  return [
+    ...issues,
+    ...scopeIssues(spec),
+    ...onceOnly(spec, "time_preset"),
+    ...onceOnly(spec, "attribution_window"),
+    ...timePresetIssues(spec),
+    ...aggregateIssues(spec)
+  ];
+}
+var SCHEDULE_ONLY_FIELDS = /* @__PURE__ */ new Set([
+  ...SCHEDULE_ONLY_METADATA_FIELDS,
+  ...SCHEDULE_ONLY_INSIGHTS_FIELDS,
+  "attribution_window"
+]);
+function scheduleOnlyFilter(filter) {
+  const parsed = parseAdRuleField(filter.field);
+  if ("refusal" in parsed) return false;
+  if (parsed.kind === "advanced" || parsed.kind === "aggregate" || parsed.kind === "formula") return true;
+  if (parsed.kind === "insights" && parsed.base !== filter.field) return true;
+  return SCHEDULE_ONLY_FIELDS.has(parsed.base);
+}
+var STATS_CHANGE_OPERATORS = ["GREATER_THAN", "LESS_THAN", "IN_RANGE", "NOT_IN_RANGE"];
+var MILESTONE_MINIMUMS = {
+  impressions: 1e3,
+  unique_impressions: 1e3,
+  reach: 1e3,
+  clicks: 10,
+  unique_clicks: 10,
+  spent: 1e3,
+  results: 5,
+  ...Object.fromEntries(
+    [
+      ...APP_EVENTS.map((event) => `app_custom_event_fb_mobile_${event}`),
+      "app_custom_event",
+      "app_custom_event_other",
+      "leadgen",
+      "like",
+      "link_click",
+      "mobile_app_install",
+      "offsite_conversion",
+      "offsite_conversion_add_to_cart",
+      "offsite_conversion_checkout",
+      ...PIXEL_EVENTS.map((event) => `offsite_conversion_fb_pixel_${event}`),
+      "offsite_engagement",
+      "post",
+      "post_comment",
+      "post_engagement",
+      "post_like",
+      "post_reaction",
+      "view_content",
+      "video_play",
+      "video_view",
+      "vote"
+    ].map((field) => [field, 1])
+  )
+};
+function milestoneMinimumIssue(trigger) {
+  if (trigger.type !== "STATS_MILESTONE" || !trigger.field) return void 0;
+  const minimum = MILESTONE_MINIMUMS[trigger.field];
+  return minimum !== void 0 && typeof trigger.value === "number" && trigger.value < minimum ? `a ${trigger.field} milestone steps by at least ${minimum}${trigger.field === "spent" ? " in the account's minor units (10.00 in a two-decimal currency)" : ""}` : void 0;
+}
+function milestoneIssue(trigger, spec) {
+  if (trigger.operator !== "EQUAL") {
+    return "a STATS_MILESTONE trigger takes operator EQUAL (it fires at every multiple of the value)";
+  }
+  const preset = filtersNamed(spec, "time_preset")[0]?.value;
+  if (preset !== void 0 && preset !== "LIFETIME") return "a STATS_MILESTONE trigger needs time_preset LIFETIME";
+  if (!trigger.field || MILESTONE_MINIMUMS[trigger.field] === void 0) {
+    return `Meta counts milestones only of ${Object.keys(MILESTONE_MINIMUMS).slice(0, 7).join(", ")} and the conversion events \u2014 not ${trigger.field}; use a STATS_CHANGE trigger for it`;
+  }
+  if (!(typeof trigger.value === "number" && trigger.value > 0))
+    return "a STATS_MILESTONE trigger takes a positive number";
+  return trigger.field === "spent" ? void 0 : milestoneMinimumIssue(trigger);
+}
+function statsTriggerIssue(trigger, spec) {
+  if (trigger.type === "STATS_MILESTONE") return milestoneIssue(trigger, spec);
+  if (trigger.type === "STATS_CHANGE" && !(trigger.operator && STATS_CHANGE_OPERATORS.includes(trigger.operator))) {
+    return `a STATS_CHANGE trigger takes ${STATS_CHANGE_OPERATORS.join(", ")}`;
+  }
+  return trigger.operator ? valueShapeIssue(trigger.operator, trigger.value, false) : "the trigger needs an operator";
+}
+function triggerShapeIssue(trigger, spec) {
+  if (trigger.type === "METADATA_CREATION") return void 0;
+  if (!trigger.field) return `a ${trigger.type} trigger needs a field`;
+  if (trigger.type === "STATS_MILESTONE") return milestoneIssue(trigger, spec);
+  const parsed = parseAdRuleField(trigger.field);
+  if ("refusal" in parsed) return parsed.refusal;
+  const isMetadata = parsed.kind === "metadata";
+  if (trigger.type === "METADATA_UPDATE") {
+    return isMetadata ? void 0 : `a METADATA_UPDATE trigger watches a metadata field, not ${trigger.field}`;
+  }
+  if (isMetadata || parsed.kind === "special") {
+    return `a ${trigger.type} trigger watches a metric, not ${trigger.field}`;
+  }
+  return statsTriggerIssue(trigger, spec);
+}
+function triggerIssues(spec) {
+  const at = (message, path = []) => ({
+    path: ["evaluation_spec", ...path],
+    message
+  });
+  if (spec.evaluation_type === "SCHEDULE") {
+    return spec.trigger ? [at("a SCHEDULE rule has no trigger \u2014 use evaluation_type TRIGGER, or drop the trigger", ["trigger"])] : [];
+  }
+  const issues = [];
+  if (!spec.trigger) {
+    issues.push(
+      at("a TRIGGER rule needs a trigger ({type, field, operator, value}) saying what change it reacts to", [
+        "trigger"
+      ])
+    );
+  } else {
+    const shape = triggerShapeIssue(spec.trigger, spec);
+    if (shape) issues.push(at(shape, ["trigger"]));
+  }
+  for (const [index, filter] of spec.filters.entries()) {
+    if (scheduleOnlyFilter(filter)) {
+      issues.push(
+        at(`${filter.field} works only on a schedule \u2014 use evaluation_type SCHEDULE, or drop it`, ["filters", index])
+      );
+    }
+  }
+  const preset = filtersNamed(spec, "time_preset")[0]?.value;
+  if (typeof preset === "string" && !TIME_PRESETS_WITH_TODAY.includes(preset)) {
+    issues.push(
+      at(
+        `a TRIGGER rule evaluates in real time, so its time_preset must include today (${TIME_PRESETS_WITH_TODAY.join(", ")}) \u2014 not ${preset}`,
+        ["filters"]
+      )
+    );
+  }
+  return issues;
+}
+function evaluationIssues(spec) {
+  return [...filterIssues(spec), ...triggerIssues(spec)];
+}
+function pairingIssues(rule, partial) {
+  const evaluationType = rule.evaluation_spec?.evaluation_type;
+  if (!evaluationType) return [];
+  const issues = [];
+  if (evaluationType === "TRIGGER") {
+    const executionType = rule.execution_spec?.execution_type;
+    if (executionType && !TRIGGER_EXECUTION_TYPES.has(executionType)) {
+      issues.push({
+        path: ["execution_spec", "execution_type"],
+        message: `a TRIGGER rule can only PAUSE, UNPAUSE or NOTIFICATION \u2014 ${executionType} needs evaluation_type SCHEDULE`
+      });
+    }
+    if (rule.schedule_spec) {
+      issues.push({
+        path: ["schedule_spec"],
+        message: "a TRIGGER rule runs the moment the metric changes, so it takes no schedule_spec \u2014 drop it"
+      });
+    }
+  } else if (!rule.schedule_spec && !partial) {
+    issues.push({
+      path: ["schedule_spec"],
+      message: "a SCHEDULE rule needs a schedule_spec (schedule_type DAILY, HOURLY, SEMI_HOURLY or CUSTOM)"
+    });
+  }
+  return issues;
+}
+var AD_RULE_CHANGE_UNITS = ["ACCOUNT_CURRENCY", "PERCENTAGE"];
+var AD_RULE_REBALANCE_TYPES = [
+  "EVEN",
+  "PROPORTIONAL",
+  "NO_PAUSE_PROPORTIONAL",
+  "MATCHED_ONLY_PROPORTIONAL"
+];
+var CHANGE_TYPES = /* @__PURE__ */ new Set(["CHANGE_BUDGET", "CHANGE_CAMPAIGN_BUDGET", "CHANGE_BID"]);
+var ACTION_LEVEL = {
+  CHANGE_BUDGET: { level: "ADSET", words: "ad sets (CHANGE_CAMPAIGN_BUDGET changes a campaign's)" },
+  CHANGE_BID: { level: "ADSET", words: "ad sets" },
+  REBALANCE_BUDGET: { level: "ADSET", words: "ad sets" },
+  CHANGE_CAMPAIGN_BUDGET: { level: "CAMPAIGN", words: "campaigns (CHANGE_BUDGET changes an ad set's)" },
+  ROTATE: { level: "AD", words: "ads, rotating within the ad sets an adset.id filter names" }
+};
+function optionAllowed(field, executionType) {
+  switch (field) {
+    case "user_ids":
+    case "alert_preferences":
+      return true;
+    case "change_spec":
+    case "execution_count_limit":
+    case "action_frequency":
+      return CHANGE_TYPES.has(executionType);
+    case "rebalance_spec":
+      return executionType === "REBALANCE_BUDGET";
+    default:
+      return false;
+  }
+}
+function isPositiveInt(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNumberPair(value) {
+  return Array.isArray(value) && value.length === 2 && value.every((bound) => typeof bound === "number") && value[0] <= value[1];
+}
+function changeSpecIssue(value) {
+  if (!isRecord2(value)) return "change_spec takes {amount, unit, limit?, target_field?}";
+  if (typeof value.amount !== "number" || value.amount === 0) return "change_spec.amount takes a non-zero number";
+  const target = value.target_field;
+  if (target !== void 0) {
+    if (typeof target !== "string" || !isInsightsField(target)) {
+      return "change_spec.target_field takes an Insights metric (e.g. cost_per, website_purchase_roas)";
+    }
+    return value.limit === void 0 || isNumberPair(value.limit) ? void 0 : "with target_field, change_spec.limit takes a [lowest, highest] pair";
+  }
+  if (!AD_RULE_CHANGE_UNITS.includes(value.unit)) {
+    return `change_spec.unit takes ${AD_RULE_CHANGE_UNITS.join(" or ")} (required unless target_field is set)`;
+  }
+  return value.limit === void 0 || typeof value.limit === "number" && value.limit > 0 ? void 0 : "change_spec.limit takes a positive amount \u2014 the most (or least) the budget or bid may reach";
+}
+function rebalanceSpecIssue(value) {
+  if (!isRecord2(value) || !AD_RULE_REBALANCE_TYPES.includes(value.type)) {
+    return `rebalance_spec.type takes ${AD_RULE_REBALANCE_TYPES.join(", ")}`;
+  }
+  const needsTarget = value.type !== "EVEN" || value.target_count !== void 0;
+  if (needsTarget && (typeof value.target_field !== "string" || !isInsightsField(value.target_field))) {
+    return "rebalance_spec needs a target_field (an Insights metric to rank by) unless type is EVEN with no target_count";
+  }
+  if (value.target_count !== void 0 && !isPositiveInt(value.target_count)) {
+    return "rebalance_spec.target_count takes a positive whole number";
+  }
+  if (typeof value.target_field === "string" && isCostField(value.target_field) && value.is_inverse !== true) {
+    return `rebalance_spec ranks by ${value.target_field}, a cost, so Meta would give the most budget to the most expensive ad sets \u2014 add is_inverse: true to favour the cheapest`;
+  }
+  return void 0;
+}
+function optionValueIssue(option) {
+  switch (option.field) {
+    case "change_spec":
+      return changeSpecIssue(option.value);
+    case "rebalance_spec":
+      return rebalanceSpecIssue(option.value);
+    case "execution_count_limit":
+    case "action_frequency":
+      return isPositiveInt(option.value) ? void 0 : `${option.field} takes a positive whole number`;
+    case "user_ids":
+      return Array.isArray(option.value) && option.value.length > 0 ? void 0 : "user_ids takes a list of Facebook user ids to notify";
+    default:
+      return void 0;
+  }
+}
+var REQUIRED_OPTION = {
+  CHANGE_BUDGET: "change_spec",
+  CHANGE_CAMPAIGN_BUDGET: "change_spec",
+  CHANGE_BID: "change_spec",
+  REBALANCE_BUDGET: "rebalance_spec"
+};
+function executionIssues(spec) {
+  const issues = [];
+  const options = spec.execution_options ?? [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, option] of options.entries()) {
+    const path = ["execution_spec", "execution_options", index];
+    if (seen.has(option.field)) issues.push({ path, message: `${option.field} is given twice` });
+    seen.add(option.field);
+    if (!optionAllowed(option.field, spec.execution_type)) {
+      issues.push({ path, message: `${spec.execution_type} does not take the ${option.field} option` });
+      continue;
+    }
+    const message = optionValueIssue(option);
+    if (message) issues.push({ path, message });
+  }
+  const required = REQUIRED_OPTION[spec.execution_type];
+  if (required && !seen.has(required)) {
+    issues.push({
+      path: ["execution_spec", "execution_options"],
+      message: `${spec.execution_type} needs a ${required} option saying how much to change`
+    });
+  }
+  return issues;
+}
+function adRuleLevel(spec) {
+  const value = spec ? filtersNamed(spec, "entity_type")[0]?.value : void 0;
+  return AD_RULE_ENTITY_TYPES.includes(value) ? value : void 0;
+}
+function rotateIssues(rule) {
+  if (rule.execution_spec?.execution_type !== "ROTATE" || !rule.evaluation_spec) return [];
+  return filtersNamed(rule.evaluation_spec, "id").length > 0 ? [
+    {
+      path: ["evaluation_spec", "filters"],
+      message: "a ROTATE rule names the ad sets whose ads it rotates with an adset.id filter (entity_type AD) \u2014 Meta refuses a bare id filter of ad sets"
+    }
+  ] : [];
+}
+function levelIssues(rule) {
+  const executionType = rule.execution_spec?.execution_type;
+  const wanted = executionType ? ACTION_LEVEL[executionType] : void 0;
+  const level = adRuleLevel(rule.evaluation_spec);
+  if (!wanted || !level || level === wanted.level) return [];
+  return [
+    {
+      path: ["execution_spec", "execution_type"],
+      message: `${executionType} acts on ${wanted.words} \u2014 set entity_type ${wanted.level}, not ${level}`
+    }
+  ];
+}
+var MINUTES_PER_DAY = 24 * 60;
+function minuteIssue(name, value) {
+  if (value === void 0) return void 0;
+  return value % 30 === 0 && value >= 0 && value <= MINUTES_PER_DAY ? void 0 : `${name} is minutes after midnight, a multiple of 30 between 0 and ${MINUTES_PER_DAY}`;
+}
+function scheduleItemIssue(item) {
+  if (item.days === void 0 && item.start_minute === void 0 && item.end_minute === void 0) {
+    return "a custom schedule entry names its days (0\u20136) and/or start_minute/end_minute \u2014 an empty one says nothing about when to run";
+  }
+  const minute = minuteIssue("start_minute", item.start_minute) ?? minuteIssue("end_minute", item.end_minute);
+  if (minute) return minute;
+  if (item.start_minute !== void 0 && item.end_minute !== void 0 && item.end_minute < item.start_minute) {
+    return "end_minute must be at or after start_minute";
+  }
+  const days = item.days ?? [];
+  if (days.some((day) => day < 0 || day > 6) || new Set(days).size !== days.length) {
+    return "days are distinct numbers from 0 (Sunday) to 6 (Saturday)";
+  }
+  return void 0;
+}
+function scheduleIssues(spec, executionType) {
+  const issues = [];
+  const items = spec.schedule ?? [];
+  if (spec.schedule_type === "CUSTOM" && items.length === 0) {
+    issues.push({
+      path: ["schedule_spec", "schedule"],
+      message: "a CUSTOM schedule needs at least one {start_minute, end_minute, days} entry"
+    });
+  }
+  if (spec.schedule_type !== "CUSTOM" && items.length > 0) {
+    issues.push({
+      path: ["schedule_spec", "schedule"],
+      message: `schedule entries need schedule_type CUSTOM, not ${spec.schedule_type}`
+    });
+  }
+  for (const [index, item] of items.entries()) {
+    const message = scheduleItemIssue(item);
+    if (message) issues.push({ path: ["schedule_spec", "schedule", index], message });
+  }
+  if (executionType === "REBALANCE_BUDGET" && spec.schedule_type !== "DAILY" && spec.schedule_type !== "CUSTOM") {
+    issues.push({
+      path: ["schedule_spec", "schedule_type"],
+      message: "a REBALANCE_BUDGET rule runs DAILY or on a CUSTOM schedule"
+    });
+  }
+  return issues;
+}
+function adRuleIssues(rule, { partial = false } = {}) {
+  return [
+    ...rule.evaluation_spec ? evaluationIssues(rule.evaluation_spec) : [],
+    ...rule.execution_spec ? executionIssues(rule.execution_spec) : [],
+    ...rule.schedule_spec ? scheduleIssues(rule.schedule_spec, rule.execution_spec?.execution_type) : [],
+    ...pairingIssues(rule, partial),
+    ...levelIssues(rule),
+    ...rotateIssues(rule)
+  ];
+}
+function addIssues(rule, ctx, partial = false) {
+  for (const issue of adRuleIssues(rule, { partial })) {
+    ctx.addIssue({ code: "custom", path: issue.path, message: issue.message });
+  }
+}
+var currencyCodeSchema = z4.string().regex(/^[A-Z]{3}$/).optional();
+var adRuleCreateSchema = z4.strictObject({
+  name: z4.string().min(1).max(255),
+  status: z4.enum(AD_RULE_CREATE_STATUSES).default("ENABLED"),
+  evaluation_spec: adRuleEvaluationSpecSchema,
+  execution_spec: adRuleExecutionSpecSchema,
+  schedule_spec: adRuleScheduleSpecSchema.optional(),
+  /** The account currency the money values are in — filled by the backend. */
+  currencyCode: currencyCodeSchema
+}).superRefine((rule, ctx) => addIssues(rule, ctx));
+var MONEY_METADATA = /* @__PURE__ */ new Set(["daily_budget", "lifetime_budget", "spend_cap", "bid_amount"]);
+var MONEY_INSIGHTS = /* @__PURE__ */ new Set([
+  "spent",
+  "today_spent",
+  "yesterday_spent",
+  "lifetime_spent",
+  "cpc",
+  "cpm",
+  "cpa",
+  "cpp"
+]);
+function unitsField(field) {
+  return field.split(/(\s+|[()])/).map((term) => {
+    const object = /^(ad|adset|campaign)\./.exec(term)?.[0] ?? "";
+    const bare = term.slice(object.length);
+    return retiredAttributionPrefix(bare) ? `${object}${LIVE_ATTRIBUTION_PREFIX}${bare.slice(bare.indexOf(":"))}` : term;
+  }).join("");
+}
+function isAdRuleMoneyField(field) {
+  const parsed = parseAdRuleField(unitsField(field));
+  if ("refusal" in parsed || parsed.kind === "formula" || parsed.kind === "special") return false;
+  if (parsed.kind === "metadata") return MONEY_METADATA.has(parsed.base);
+  return MONEY_INSIGHTS.has(parsed.base) || parsed.base.startsWith("cost_per");
+}
+var adRuleUpdateSchema = z4.strictObject({
+  name: z4.string().min(1).max(255).optional(),
+  status: z4.enum(AD_RULE_UPDATE_STATUSES).optional(),
+  /** Each spec is replaced whole — Meta takes no partial spec on update. */
+  evaluation_spec: adRuleEvaluationSpecSchema.optional(),
+  execution_spec: adRuleExecutionSpecSchema.optional(),
+  schedule_spec: adRuleScheduleSpecSchema.optional(),
+  /**
+   * Run the rule once, now (`POST /{rule}/execute`), after any change staged
+   * beside it — the rule acts on what matches it at that moment, whatever its
+   * schedule and even while it is off. Meta ignores `validate_only` there (a
+   * validate-only execute ran the rule, its history shows it; live on v26.0,
+   * 2026-10-15), so it is never dry-run.
+   */
+  run_now: z4.literal(true).optional(),
+  currencyCode: currencyCodeSchema
+}).refine(
+  (p) => Object.entries(p).some(([key, value]) => key !== "currencyCode" && value !== void 0),
+  "update needs at least one field"
+).refine((p) => !(p.run_now && p.status === "DELETED"), "a rule being deleted cannot also run now \u2014 pick one").superRefine((rule, ctx) => addIssues(rule, ctx, true));
+var metaAdRuleHistoryQuerySchema = z4.strictObject({
+  accountId: z4.string().min(1),
+  ruleId: z4.string().regex(/^\d+$/).optional(),
+  objectId: z4.string().regex(/^\d+$/).optional(),
+  /** Meta's action names, e.g. PAUSED, UNPAUSED, CHANGED_BUDGET, CHANGED_BID, NOTIFICATION. */
+  action: z4.string().min(1).optional(),
+  hideNoChanges: z4.boolean().optional(),
+  limit: z4.number().int().min(1).max(500).optional()
+});
+
+// ../api/src/ads-meta/adSetCompliance.ts
+import { z as z5 } from "zod";
+var placementSoftOptOutSchema = z5.strictObject({
+  facebook_positions: z5.array(z5.enum(FACEBOOK_POSITIONS)).min(1).optional(),
+  instagram_positions: z5.array(z5.enum(INSTAGRAM_POSITIONS)).min(1).optional(),
+  audience_network_positions: z5.array(z5.enum(AUDIENCE_NETWORK_POSITIONS)).min(1).optional(),
+  messenger_positions: z5.array(z5.enum(MESSENGER_POSITIONS)).min(1).optional(),
+  threads_positions: z5.array(z5.enum(THREADS_POSITIONS)).min(1).optional()
+}).refine(
+  (spec) => Object.values(spec).some((positions) => positions !== void 0),
+  "name at least one position Meta may spend on (e.g. audience_network_positions: [classic])"
+);
+var REGIONAL_REGULATED_CATEGORIES = [
+  "TAIWAN_FINSERV",
+  "AUSTRALIA_FINSERV",
+  "INDIA_FINSERV",
+  "TAIWAN_UNIVERSAL",
+  "SINGAPORE_UNIVERSAL",
+  "THAILAND_UNIVERSAL",
+  "BRAZIL_REGULATION"
+];
+var IDENTITY_PREFIX = {
+  TAIWAN_FINSERV: "taiwan_finserv",
+  AUSTRALIA_FINSERV: "australia_finserv",
+  INDIA_FINSERV: "india_finserv",
+  TAIWAN_UNIVERSAL: "taiwan_universal",
+  SINGAPORE_UNIVERSAL: "singapore_universal",
+  THAILAND_UNIVERSAL: "universal",
+  BRAZIL_REGULATION: "universal"
+};
+var identityId = z5.string().regex(/^\d+$/, "a verified advertiser id (digits)");
+var IDENTITY_KEYS = [...new Set(Object.values(IDENTITY_PREFIX))].flatMap((prefix) => [
+  `${prefix}_beneficiary`,
+  `${prefix}_payer`
+]);
+var regionalRegulationIdentitiesSchema = z5.strictObject(
+  Object.fromEntries(IDENTITY_KEYS.map((key) => [key, identityId.optional()]))
+);
+var regionalRegulationFields = {
+  regional_regulated_categories: z5.array(z5.enum(REGIONAL_REGULATED_CATEGORIES)).min(1).optional(),
+  regional_regulation_identities: regionalRegulationIdentitiesSchema.optional()
+};
+function validateRegionalRegulation(p, ctx) {
+  const categories = p.regional_regulated_categories ?? [];
+  const identities = p.regional_regulation_identities ?? {};
+  for (const category of categories) {
+    const prefix = IDENTITY_PREFIX[category];
+    const missing = [`${prefix}_beneficiary`, `${prefix}_payer`].filter((key) => !identities[key]);
+    if (missing.length > 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["regional_regulation_identities"],
+        message: `${category} needs ${missing.join(" and ")} in regional_regulation_identities \u2014 the verified advertiser ids from Meta's advertiser verification (Meta refuses it without them, 3858548)`
+      });
+    }
+  }
+  if (categories.includes("TAIWAN_FINSERV") && !categories.includes("TAIWAN_UNIVERSAL")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["regional_regulated_categories"],
+      message: "a Taiwan financial-services ad set declares TAIWAN_UNIVERSAL beside TAIWAN_FINSERV"
+    });
+  }
+}
+var SOFT_PLATFORM = {
+  facebook_positions: "facebook",
+  instagram_positions: "instagram",
+  audience_network_positions: "audience_network",
+  messenger_positions: "messenger",
+  threads_positions: "threads"
+};
+function softOptOutPlacementIssue(soft, targeting, isCreate) {
+  if (!soft || !isCreate && targeting === void 0) return void 0;
+  const platforms = Array.isArray(targeting?.publisher_platforms) ? targeting.publisher_platforms : [];
+  if (platforms.length === 0) {
+    return "limited spend reaches placements the ad set leaves out, so it needs manual placements (targeting.publisher_platforms and positions) \u2014 with automatic placements Meta drops it";
+  }
+  for (const [key, positions] of Object.entries(soft)) {
+    const platform = SOFT_PLATFORM[key];
+    const running = targeting?.[key];
+    if (!platform || !positions || !platforms.includes(platform)) continue;
+    const runs = Array.isArray(running) ? running : void 0;
+    const overlap = positions.filter((position) => runs === void 0 || runs.includes(position));
+    if (overlap.length > 0) {
+      return `the ad set already runs on ${overlap.map((position) => `${platform} ${position}`).join(", ")} \u2014 limited spend names only positions it leaves out`;
+    }
+  }
+  return void 0;
+}
+
+// ../api/src/ads-meta/copies.ts
+import { z as z6 } from "zod";
+var COPY_STATUS_OPTIONS = ["PAUSED", "ACTIVE", "INHERITED_FROM_SOURCE"];
+var COPY_RENAME_STRATEGIES = ["DEEP_RENAME", "ONLY_TOP_LEVEL_RENAME", "NO_RENAME"];
+var DEEP_COPY_MAX_ADS = 51;
+var sourceIdSchema = z6.string().regex(
+  NUMERIC_ID_REGEX,
+  "the source must be a published Meta id \u2014 to repeat something staged in this chat, stage it again"
+);
+var destinationSchema = z6.union([
+  z6.string().regex(NUMERIC_ID_REGEX, "expected a numeric id"),
+  z6.string().regex(TEMP_REF_REGEX, "expected a meta_temp_* reference")
+]);
+var copiedTreeSchema = z6.strictObject({
+  adSets: z6.number().int().nonnegative().optional(),
+  ads: z6.number().int().nonnegative()
+});
+var naming = {
+  status_option: z6.enum(COPY_STATUS_OPTIONS).optional(),
+  rename_strategy: z6.enum(COPY_RENAME_STRATEGIES).optional(),
+  rename_prefix: z6.string().min(1).max(100).optional(),
+  rename_suffix: z6.string().min(1).max(100).optional()
+};
+var schedule = {
+  start_time: z6.number().int().positive().optional(),
+  end_time: z6.number().int().positive().optional()
+};
+function copyIssues(p, ctx) {
+  if (p.rename_strategy === "NO_RENAME" && (p.rename_prefix || p.rename_suffix)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["rename_strategy"],
+      message: "NO_RENAME keeps every name as it is, so a prefix or suffix would be ignored \u2014 drop one of them"
+    });
+  }
+  if (p.start_time !== void 0 && p.end_time !== void 0 && p.end_time <= p.start_time) {
+    ctx.addIssue({ code: "custom", path: ["end_time"], message: "end_time must be after start_time" });
+  }
+  if (p.deep_copy && p.sourceTree && p.sourceTree.ads > DEEP_COPY_MAX_ADS) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["deep_copy"],
+      message: `Meta copies at most ${DEEP_COPY_MAX_ADS} ads in one go and this holds ${p.sourceTree.ads} \u2014 copy its ad sets one by one (\`adsets copy <id> --deep --to-campaign <copy>\`)`
+    });
+  }
+}
+var campaignCopySchema = z6.strictObject({
+  source_id: sourceIdSchema,
+  /** Copy the ad sets and ads too. Without it Meta copies the campaign alone. */
+  deep_copy: z6.boolean().optional(),
+  ...naming,
+  /** For a deep copy only: when the copied ad sets start and end (else they keep the originals'). */
+  ...schedule,
+  sourceTree: copiedTreeSchema.optional()
+}).superRefine((p, ctx) => {
+  if (!p.deep_copy && (p.start_time !== void 0 || p.end_time !== void 0)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["start_time"],
+      message: "start and end apply to the copied ad sets, so they need a deep copy (--deep)"
+    });
+  }
+  copyIssues(p, ctx);
+});
+var adSetCopySchema = z6.strictObject({
+  source_id: sourceIdSchema,
+  /** The campaign the copy goes into; omitted, it stays beside the original. */
+  campaign_id: destinationSchema.optional(),
+  /** Copy the ads too. */
+  deep_copy: z6.boolean().optional(),
+  ...naming,
+  ...schedule,
+  sourceTree: copiedTreeSchema.optional()
+}).superRefine(copyIssues);
+var adCopySchema = z6.strictObject({
+  source_id: sourceIdSchema,
+  /** The ad set the copy goes into; omitted, it stays beside the original. */
+  adset_id: destinationSchema.optional(),
+  ...naming
+}).superRefine(copyIssues);
+
+// ../api/src/ads-meta/instantExperiences.ts
+import { z as z7 } from "zod";
+var tempRefSchema2 = z7.string().regex(TEMP_REF_REGEX, "expected a meta_temp_* reference");
+var httpsUrlSchema2 = z7.string().url().refine((value) => value.startsWith("https://"), "must be an https URL");
+var CANVAS_LIMITS = { nameMax: 100, elementsMax: 20, textMax: 1e3, buttonTextMax: 30 };
+var textElement = z7.strictObject({
+  type: z7.literal("text"),
+  text: z7.string().trim().min(1).max(CANVAS_LIMITS.textMax)
+});
+var buttonFields = {
+  text: z7.string().trim().min(1).max(CANVAS_LIMITS.buttonTextMax),
+  url: httpsUrlSchema2
+};
+var buttonElement = z7.strictObject({
+  type: z7.literal("button"),
+  ...buttonFields,
+  /** Meta's `button_style`: BUTTON_FILLED or BUTTON_OUTLINE (the two it took, live). */
+  style: z7.enum(["filled", "outline"]).default("filled")
+});
+var idOrRefSchema = z7.union([z7.string().regex(NUMERIC_ID_REGEX), tempRefSchema2]);
+var photoElement = z7.strictObject({
+  type: z7.literal("photo"),
+  /**
+   * A photo on the Page — the only picture Meta takes in an experience: its id,
+   * or the ref of a Page photo this chat uploads (`pages photos upload`).
+   */
+  photo_id: idOrRefSchema
+});
+var videoElement = z7.strictObject({
+  type: z7.literal("video"),
+  /** A video of the ad account (`baker ads meta media`), by id. */
+  video_id: z7.string().regex(NUMERIC_ID_REGEX).optional(),
+  /** A library video this chat uploads (`media upload --kind video`). */
+  videoRef: tempRefSchema2.optional()
+}).refine(
+  (p) => p.video_id === void 0 !== (p.videoRef === void 0),
+  "a video element names video_id OR videoRef"
+);
+var productSetElement = z7.strictObject({
+  type: z7.literal("product_set"),
+  /** A product set's id, or the ref of one this chat creates. */
+  product_set_id: idOrRefSchema,
+  /** Meta's `show_in_feed`: the products also show under the ad itself — what makes a collection ad. */
+  show_in_feed: z7.boolean().default(true),
+  /** Catalog tokens allowed, e.g. "{{product.name}}". */
+  item_headline: z7.string().trim().min(1).max(200).optional(),
+  item_description: z7.string().trim().min(1).max(200).optional()
+});
+var footerElement = z7.strictObject({ type: z7.literal("footer"), ...buttonFields });
+var canvasElementSchema = z7.discriminatedUnion("type", [
+  textElement,
+  buttonElement,
+  photoElement,
+  videoElement,
+  productSetElement,
+  footerElement
+]);
+var canvasCreateSchema = z7.strictObject({
+  page_id: z7.string().regex(NUMERIC_ID_REGEX),
+  name: z7.string().trim().min(1).max(CANVAS_LIMITS.nameMax),
+  /** Six hex digits, no `#` — e.g. FFFFFF. */
+  background_color: z7.string().regex(/^[0-9A-Fa-f]{6}$/, "a colour is six hex digits, e.g. FFFFFF").optional(),
+  elements: z7.array(canvasElementSchema).min(1).max(CANVAS_LIMITS.elementsMax),
+  /** Publish it with the Session: an ad can only open a published experience, and a published one is fixed. */
+  publish: z7.boolean().default(true)
+}).superRefine((p, ctx) => {
+  const footers = p.elements.flatMap((element, index) => element.type === "footer" ? [index] : []);
+  if (footers.length > 1 || footers.length === 1 && footers[0] !== p.elements.length - 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["elements"],
+      message: "an experience has at most one footer, and it is the last element"
+    });
+  }
+});
+var canvasUpdateSchema = z7.strictObject({
+  name: z7.string().trim().min(1).max(CANVAS_LIMITS.nameMax).optional(),
+  publish: z7.literal(true).optional()
+}).refine((p) => p.name !== void 0 || p.publish !== void 0, "rename the experience or publish it");
+
+// ../api/src/ads-meta/leadForms.ts
+import { z as z8 } from "zod";
+var httpsUrlSchema3 = z8.string().url().refine((value) => value.startsWith("https://"), "must be an https URL");
+var LEAD_FORM_LOCALES = [
+  "AR_AR",
+  "CS_CZ",
+  "DA_DK",
+  "DE_DE",
+  "EL_GR",
+  "EN_GB",
+  "EN_US",
+  "ES_ES",
+  "ES_LA",
+  "FI_FI",
+  "FR_FR",
+  "HE_IL",
+  "HI_IN",
+  "HU_HU",
+  "ID_ID",
+  "IT_IT",
+  "JA_JP",
+  "KO_KR",
+  "NB_NO",
+  "NL_NL",
+  "PL_PL",
+  "PT_BR",
+  "PT_PT",
+  "RO_RO",
+  "RU_RU",
+  "SV_SE",
+  "TH_TH",
+  "TR_TR",
+  "VI_VN",
+  "ZH_CN",
+  "ZH_HK",
+  "ZH_TW"
+];
+var LEAD_FORM_QUESTION_TYPES = [
+  "CUSTOM",
+  "FULL_NAME",
+  "FIRST_NAME",
+  "LAST_NAME",
+  "EMAIL",
+  "PHONE",
+  "PHONE_OTP",
+  "WORK_EMAIL",
+  "WORK_PHONE_NUMBER",
+  "WHATSAPP_NUMBER",
+  "COMPANY_NAME",
+  "JOB_TITLE",
+  "WEBSITE",
+  "STREET_ADDRESS",
+  "ADDRESS_LINE_TWO",
+  "CITY",
+  "STATE",
+  "PROVINCE",
+  "COUNTRY",
+  "ZIP",
+  "POST_CODE",
+  "DOB",
+  "GENDER",
+  "MARITIAL_STATUS",
+  "RELATIONSHIP_STATUS",
+  "MILITARY_STATUS",
+  "EDUCATION_LEVEL",
+  "VIN",
+  "LICENSE_PLATE",
+  "EMAIL_ALIAS",
+  "DATE_TIME",
+  "SLIDER",
+  "ID_CPF",
+  "ID_AR_DNI",
+  "ID_CL_RUT",
+  "ID_CO_CC",
+  "ID_EC_CI",
+  "ID_PE_DNI",
+  "ID_MX_RFC",
+  "USER_PROVIDED_PHONE_NUMBER",
+  "STORE_LOOKUP",
+  "STORE_LOOKUP_WITH_TYPEAHEAD",
+  "LOCAL_DEALER",
+  "JOIN_CODE",
+  "FACEBOOK_LEAD_ID",
+  "MESSENGER",
+  "THREAD_LINK"
+];
+var WORDED_QUESTION_TYPES = /* @__PURE__ */ new Set(["CUSTOM", "DATE_TIME", "SLIDER"]);
+var NATIONAL_ID_COUNTRY = {
+  ID_AR_DNI: "AR",
+  ID_CPF: "BR",
+  ID_CL_RUT: "CL",
+  ID_CO_CC: "CO",
+  ID_EC_CI: "EC",
+  ID_PE_DNI: "PE",
+  ID_MX_RFC: "MX"
+};
+var REFUSED_QUESTION_TYPES = {
+  USER_PROVIDED_PHONE_NUMBER: "Meta refuses it on a form made through its API \u2014 ask for PHONE instead",
+  LOCAL_DEALER: "Meta refuses it on a form made through its API (it needs a dealer setup in Ads Manager)",
+  JOIN_CODE: "Meta refuses it on a form made through its API",
+  FACEBOOK_LEAD_ID: "Meta refuses it on a form made through its API",
+  MESSENGER: "Meta refuses it on a form made through its API",
+  THREAD_LINK: "Meta refuses it on a form made through its API",
+  STORE_LOOKUP: "a store locator needs a store-locations setup Meta does not open to Baker (#3, no capability) \u2014 build that form in Ads Manager",
+  STORE_LOOKUP_WITH_TYPEAHEAD: "a store locator needs a store-locations setup Meta does not open to Baker (#3, no capability) \u2014 build that form in Ads Manager"
+};
+var LEAD_FORM_LIMITS = {
+  nameMax: 255,
+  labelMax: 255,
+  questionsMax: 50,
+  wordedQuestionsMax: 15,
+  optionsMin: 2,
+  optionsMax: 100,
+  optionMax: 255,
+  privacyLinkTextMax: 70,
+  textMax: 1e3,
+  introItemsMax: 5,
+  buttonTextMax: 60,
+  checkboxesMax: 10,
+  trackingParametersMax: 20
+};
+var keySchema = z8.string().trim().min(1).max(100).regex(/^[A-Za-z0-9_]+$/, "a key is letters, digits and underscores");
+var optionSchema = z8.strictObject({
+  value: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.optionMax),
+  /** What the answer is stored as on a lead; Baker numbers them when left out (Meta needs one). */
+  key: keySchema.optional()
+});
+var questionTypeSchema = z8.preprocess(
+  (value) => value === "ZIP_CODE" ? "ZIP" : value,
+  z8.enum(LEAD_FORM_QUESTION_TYPES)
+);
+var leadFormQuestionSchema = z8.strictObject({
+  type: questionTypeSchema,
+  /** The question's wording — CUSTOM, DATE_TIME and SLIDER only; Meta words the rest in the form's language. */
+  label: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.labelMax).optional(),
+  /** The field name the answer is stored under on a lead (Meta picks one when left out). */
+  key: keySchema.optional(),
+  /** A short note under the question, e.g. "We'll call to confirm the time." */
+  inlineContext: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.textMax).optional(),
+  /** Multiple choice answers (CUSTOM only). */
+  options: z8.array(optionSchema).max(LEAD_FORM_LIMITS.optionsMax).optional()
+});
+var THANK_YOU_BUTTON_TYPES = [
+  "VIEW_WEBSITE",
+  "DOWNLOAD",
+  "BOOK_ON_WEBSITE",
+  "CALL_BUSINESS",
+  "WHATSAPP",
+  "P2B_MESSENGER",
+  "PROMO_CODE",
+  "NONE",
+  "MESSAGE_BUSINESS",
+  "SCHEDULE_APPOINTMENT",
+  "VIEW_ON_FACEBOOK"
+];
+var REFUSED_THANK_YOU_BUTTONS = {
+  MESSAGE_BUSINESS: 'Meta answers "This button type is not yet supported" \u2014 use P2B_MESSENGER to open Messenger',
+  SCHEDULE_APPOINTMENT: 'Meta answers "Appointment integration is missing" \u2014 it needs a booking integration set up in Meta Business Suite',
+  VIEW_ON_FACEBOOK: "it opens a downloadable file Meta takes only as an upload Baker cannot send \u2014 use DOWNLOAD with a link"
+};
+var WEBSITE_BUTTONS = /* @__PURE__ */ new Set(["VIEW_WEBSITE", "DOWNLOAD", "BOOK_ON_WEBSITE"]);
+var thankYouSchema = z8.strictObject({
+  title: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.nameMax),
+  body: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.textMax).optional(),
+  buttonType: z8.enum(THANK_YOU_BUTTON_TYPES).default("VIEW_WEBSITE"),
+  buttonText: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.buttonTextMax).optional(),
+  /** Where VIEW_WEBSITE, DOWNLOAD and BOOK_ON_WEBSITE go; defaults to the form's follow-up link. */
+  websiteUrl: httpsUrlSchema3.optional(),
+  /** CALL_BUSINESS: the number, with its country. */
+  businessPhoneNumber: z8.string().trim().min(5).max(30).optional(),
+  countryCode: z8.string().regex(/^[A-Z]{2}$/, "a two-letter country code, e.g. US").optional(),
+  /** Also offer to continue the conversation in Messenger. */
+  enableMessenger: z8.boolean().optional()
+});
+var introSchema = z8.strictObject({
+  title: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.nameMax),
+  /** PARAGRAPH_STYLE: one paragraph. LIST_STYLE: up to five bullet points. */
+  style: z8.enum(["PARAGRAPH_STYLE", "LIST_STYLE"]).default("PARAGRAPH_STYLE"),
+  content: z8.array(z8.string().trim().min(1).max(LEAD_FORM_LIMITS.textMax)).min(1).max(LEAD_FORM_LIMITS.introItemsMax),
+  buttonText: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.buttonTextMax).optional(),
+  /** A photo already on the Page, by id — the only cover Meta takes from Baker. */
+  coverPhotoId: z8.string().regex(NUMERIC_ID_REGEX).optional()
+});
+var disclaimerSchema = z8.strictObject({
+  title: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.nameMax).optional(),
+  body: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.textMax),
+  /** Words of the body that link somewhere — each `text` must appear in the body. */
+  links: z8.array(z8.strictObject({ text: z8.string().trim().min(1), url: httpsUrlSchema3 })).max(5).optional(),
+  checkboxes: z8.array(
+    z8.strictObject({
+      text: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.textMax),
+      key: keySchema.optional(),
+      /** Whether the box must be ticked to submit (Meta's default: required). */
+      required: z8.boolean().default(true),
+      checkedByDefault: z8.boolean().default(false)
+    })
+  ).max(LEAD_FORM_LIMITS.checkboxesMax).optional()
+});
+function refuseQuestion(question, index, ctx) {
+  const path = ["questions", index];
+  const refused = REFUSED_QUESTION_TYPES[question.type];
+  if (refused) {
+    ctx.addIssue({ code: "custom", path: [...path, "type"], message: `${question.type}: ${refused}` });
+  }
+  const worded = WORDED_QUESTION_TYPES.has(question.type);
+  if (worded && !question.label) {
+    ctx.addIssue({ code: "custom", path: [...path, "label"], message: `${question.type} questions need a label` });
+  }
+  if (!worded && question.label) {
+    ctx.addIssue({
+      code: "custom",
+      path: [...path, "label"],
+      message: `Meta words ${question.type} itself, in the form's language \u2014 drop the label, or ask a CUSTOM question`
+    });
+  }
+  if (question.options && question.type !== "CUSTOM") {
+    ctx.addIssue({ code: "custom", path: [...path, "options"], message: "only a CUSTOM question takes answers" });
+  }
+  if (question.options && question.options.length < LEAD_FORM_LIMITS.optionsMin) {
+    ctx.addIssue({
+      code: "custom",
+      path: [...path, "options"],
+      message: "a multiple-choice question needs at least 2 answers"
+    });
+  }
+  if (question.inlineContext && !worded) {
+    ctx.addIssue({
+      code: "custom",
+      path: [...path, "inlineContext"],
+      message: "a note under the question goes on a CUSTOM, DATE_TIME or SLIDER question"
+    });
+  }
+}
+function storedKey(question) {
+  return question.key ?? (WORDED_QUESTION_TYPES.has(question.type) ? void 0 : question.type.toLowerCase());
+}
+function refuseQuestions(questions, ctx) {
+  questions.forEach((question, index) => {
+    refuseQuestion(question, index, ctx);
+  });
+  const worded = questions.filter((question) => WORDED_QUESTION_TYPES.has(question.type)).length;
+  if (worded > LEAD_FORM_LIMITS.wordedQuestionsMax) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["questions"],
+      message: `Meta allows at most ${LEAD_FORM_LIMITS.wordedQuestionsMax} custom questions (CUSTOM, DATE_TIME, SLIDER) on a form`
+    });
+  }
+  const ids = questions.filter((question) => question.type in NATIONAL_ID_COUNTRY);
+  if (ids.length > 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["questions"],
+      message: "a form asks for one national ID at most, and its ads must target only that ID's country"
+    });
+  }
+  const seen = /* @__PURE__ */ new Map();
+  questions.forEach((question, index) => {
+    const key = storedKey(question);
+    const typeKey = `${question.type}:${question.label ?? ""}`;
+    for (const id of [key && `key:${key}`, `q:${typeKey}`]) {
+      if (!id) continue;
+      if (seen.has(id)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["questions", index],
+          message: id.startsWith("key:") ? `two questions share the key "${key}"` : "duplicate question"
+        });
+      }
+      seen.set(id, index);
+    }
+  });
+}
+function refuseThankYou(thankYou, followUpActionUrl, ctx) {
+  const path = ["thankYou"];
+  const refused = REFUSED_THANK_YOU_BUTTONS[thankYou.buttonType];
+  if (refused) {
+    ctx.addIssue({ code: "custom", path: [...path, "buttonType"], message: `${thankYou.buttonType}: ${refused}` });
+  }
+  if (thankYou.buttonType !== "NONE" && thankYou.buttonType !== "VIEW_WEBSITE" && !thankYou.buttonText) {
+    ctx.addIssue({ code: "custom", path: [...path, "buttonText"], message: "the thank-you button needs its text" });
+  }
+  if (WEBSITE_BUTTONS.has(thankYou.buttonType) && !thankYou.websiteUrl && !followUpActionUrl) {
+    ctx.addIssue({
+      code: "custom",
+      path: [...path, "websiteUrl"],
+      message: `a ${thankYou.buttonType} button needs the website it opens (websiteUrl or followUpActionUrl)`
+    });
+  }
+  if (thankYou.buttonType === "CALL_BUSINESS" && (!thankYou.businessPhoneNumber || !thankYou.countryCode)) {
+    ctx.addIssue({
+      code: "custom",
+      path: [...path, "businessPhoneNumber"],
+      message: "a CALL_BUSINESS button needs businessPhoneNumber and its countryCode"
+    });
+  }
+}
+function refuseIntro(intro, ctx) {
+  if (intro.style === "PARAGRAPH_STYLE" && intro.content.length !== 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["intro", "content"],
+      message: "a PARAGRAPH_STYLE intro holds exactly one paragraph \u2014 use LIST_STYLE for bullet points"
+    });
+  }
+}
+function refuseDisclaimer(disclaimer, ctx) {
+  for (const [index, link] of (disclaimer.links ?? []).entries()) {
+    if (!disclaimer.body.includes(link.text)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["disclaimer", "links", index, "text"],
+        message: `"${link.text}" is not in the disclaimer's text \u2014 a link is words of the text`
+      });
+    }
+  }
+}
+var leadFormCreateSchema = z8.strictObject({
+  page_id: z8.string().regex(NUMERIC_ID_REGEX),
+  /** Unique among the Page's forms — Meta refuses a name the Page already has. */
+  name: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.nameMax),
+  locale: z8.enum(LEAD_FORM_LOCALES).default("EN_US"),
+  /** The headline above the questions. */
+  questionPageHeadline: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.nameMax).optional(),
+  questions: z8.array(leadFormQuestionSchema).min(1).max(LEAD_FORM_LIMITS.questionsMax),
+  privacyPolicyUrl: httpsUrlSchema3,
+  privacyPolicyLinkText: z8.string().trim().min(1).max(LEAD_FORM_LIMITS.privacyLinkTextMax).default("Privacy Policy"),
+  /** Where "View website" goes after submitting. Required without a thank-you screen. */
+  followUpActionUrl: httpsUrlSchema3.optional(),
+  /** Higher intent: people review and confirm their answers before submitting. Off = more volume. */
+  optimizedForQuality: z8.boolean().default(false),
+  /** The intro screen before the questions (Meta's context card). */
+  intro: introSchema.optional(),
+  /** Extra terms and consent checkboxes shown with the privacy policy. */
+  disclaimer: disclaimerSchema.optional(),
+  thankYou: thankYouSchema.optional(),
+  /**
+   * "restricted": only people the ad was shown to can open the form (Meta's
+   * default when unset). "open": anyone the ad is shared with can.
+   */
+  sharing: z8.enum(["restricted", "open"]).optional(),
+  /** Confirm the phone number with a code sent by text message. Needs a PHONE question. */
+  smsVerification: z8.boolean().optional(),
+  /** Name/value pairs Meta adds to every lead's answers, e.g. { "campaign": "spring" }. */
+  trackingParameters: z8.record(keySchema, z8.string().trim().min(1).max(LEAD_FORM_LIMITS.optionMax)).refine(
+    (value) => Object.keys(value).length <= LEAD_FORM_LIMITS.trackingParametersMax,
+    `at most ${LEAD_FORM_LIMITS.trackingParametersMax} tracking parameters`
+  ).optional()
+}).superRefine((form, ctx) => {
+  refuseQuestions(form.questions, ctx);
+  if (form.thankYou) {
+    refuseThankYou(form.thankYou, form.followUpActionUrl, ctx);
+  } else if (!form.followUpActionUrl) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["followUpActionUrl"],
+      message: "a form without a thank-you screen needs followUpActionUrl (Meta's View website button)"
+    });
+  }
+  if (form.intro) refuseIntro(form.intro, ctx);
+  if (form.disclaimer) refuseDisclaimer(form.disclaimer, ctx);
+  if (form.smsVerification && !form.questions.some((question) => question.type === "PHONE")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["smsVerification"],
+      message: "text-message verification needs a PHONE question"
+    });
+  }
+});
+var leadFormUpdateSchema = z8.looseObject({ status: z8.enum(["ARCHIVED", "ACTIVE"]).optional() }).superRefine((p, ctx) => {
+  const others = Object.keys(p).filter((key) => key !== "status");
+  if (others.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: [others[0] ?? "status"],
+      message: `Meta keeps an Instant Form's ${others.join(", ")} as they were once the form exists (it answers success and changes nothing). Make a changed copy instead: \`baker ads meta lead-forms duplicate <formId> --name "\u2026" --file changes.json\`, point the ads at the copy, then \`lead-forms archive <formId>\`.`
+    });
+  }
+  if (p.status === void 0 && others.length === 0) {
+    ctx.addIssue({ code: "custom", path: ["status"], message: "archive the form or unarchive it (status)" });
+  }
+});
+
+// ../api/src/ads-meta/mediaSpecs.ts
+var RATIO_4_5 = 4 / 5;
+var RATIO_9_16 = 9 / 16;
+var VIDEO_MAX_SECONDS = [
+  ["Facebook Stories", 3 * 60],
+  ["Reels", 15 * 60],
+  ["Instagram feed and Stories", 60 * 60],
+  ["Facebook feed", 241 * 60]
+];
+var POSITION_MAX_SECONDS = {
+  facebook: {
+    feed: ["Facebook feed", 241 * 60],
+    story: ["Facebook Stories", 3 * 60],
+    facebook_reels: ["Facebook Reels", 15 * 60],
+    instream_video: ["Facebook in-stream", 10 * 60]
+  },
+  instagram: {
+    stream: ["Instagram feed", 60 * 60],
+    story: ["Instagram Stories", 60 * 60],
+    explore: ["Instagram Explore", 60 * 60],
+    reels: ["Instagram Reels", 15 * 60],
+    profile_reels: ["Instagram profile Reels", 15 * 60]
+  },
+  messenger: { story: ["Messenger Stories", 60] }
+};
+var PLACEMENT_SLOTS = ["feed", "stories", "reels", "right_column", "default"];
+
+// ../api/src/ads-meta/messaging.ts
+import { z as z9 } from "zod";
+var APP_DESTINATIONS = ["MESSENGER", "WHATSAPP", "INSTAGRAM_DIRECT"];
+var MESSAGING_CTA_DESTINATION = {
+  MESSAGE_PAGE: "MESSENGER",
+  WHATSAPP_MESSAGE: "WHATSAPP",
+  INSTAGRAM_MESSAGE: "INSTAGRAM_DIRECT"
+};
+var MESSAGING_DESTINATION_TYPES = [
+  "MESSENGER",
+  "WHATSAPP",
+  "INSTAGRAM_DIRECT",
+  "MESSAGING_MESSENGER_WHATSAPP",
+  "MESSAGING_INSTAGRAM_DIRECT_MESSENGER",
+  "MESSAGING_INSTAGRAM_DIRECT_WHATSAPP",
+  "MESSAGING_INSTAGRAM_DIRECT_MESSENGER_WHATSAPP"
+];
+var WELCOME_LIMITS = { textMax: 300, iceBreakerTitleMax: 80, iceBreakerResponseMax: 300, iceBreakersMax: 4 };
+var welcomeMessageSchema = z9.strictObject({
+  greeting: z9.string().trim().min(1).max(WELCOME_LIMITS.textMax),
+  iceBreakers: z9.array(
+    z9.strictObject({
+      question: z9.string().trim().min(1).max(WELCOME_LIMITS.iceBreakerTitleMax),
+      answer: z9.string().trim().min(1).max(WELCOME_LIMITS.iceBreakerResponseMax)
+    })
+  ).min(1).max(WELCOME_LIMITS.iceBreakersMax).optional(),
+  autofill: z9.string().trim().min(1).max(WELCOME_LIMITS.textMax).optional()
+}).refine((p) => !(p.iceBreakers && p.autofill), {
+  message: "a greeting offers questions to tap OR a message to send, not both",
+  path: ["autofill"]
+});
+
+// ../api/src/ads-meta/pagePhotos.ts
+import { z as z10 } from "zod";
+var httpsUrlSchema4 = z10.string().url().refine((value) => value.startsWith("https://"), "must be an https URL");
+var pagePhotoCreateSchema = z10.strictObject({
+  page_id: z10.string().regex(NUMERIC_ID_REGEX),
+  /** A Baker library image — staging fills `url` with its Baker address. */
+  bakerImageId: z10.string().min(1).max(64).optional(),
+  /** A public https picture address Meta can fetch. */
+  url: httpsUrlSchema4.optional(),
+  /** Shown with the photo in the Page's library only; it is never posted. */
+  caption: z10.string().trim().min(1).max(2e3).optional()
+}).refine((p) => p.bakerImageId !== void 0 || p.url !== void 0, "a Page photo names bakerImageId or url");
+var pagePhotoUpdateSchema = z10.strictObject({ status: z10.literal("DELETED") });
+
+// ../api/src/ads-meta/reachFrequency.ts
+import { z as z11 } from "zod";
+var unixSeconds = z11.number().int().positive();
+var INSTREAM_PACKAGES = [
+  "NORMAL",
+  "PREMIUM",
+  "SPORTS",
+  "ENTERTAINMENT",
+  "BEAUTY",
+  "FOOD",
+  "SPANISH",
+  "REGULAR_ANIMALS_PETS",
+  "REGULAR_FOOD",
+  "REGULAR_GAMES",
+  "REGULAR_POLITICS",
+  "REGULAR_SPORTS",
+  "REGULAR_STYLE",
+  "REGULAR_TV_MOVIES"
+];
+var reachFrequencyPredictionRequestSchema = z11.strictObject({
+  accountId: z11.string().regex(NUMERIC_ID_REGEX),
+  /** `reach`: how many people a budget reaches. `budget`: what a reach costs. */
+  solveFor: z11.enum(["reach", "budget"]),
+  /** Lifetime budget, major units — with solveFor reach. */
+  budget: z11.string().regex(/^\d+(\.\d{1,2})?$/).optional(),
+  /** People to reach — with solveFor budget. Meta's floor is usually 200,000 per country. */
+  reach: z11.number().int().positive().optional(),
+  start_time: unixSeconds,
+  end_time: unixSeconds,
+  /** Most times one person sees the ad in each `frequencyCapDays`. */
+  frequencyCap: z11.number().int().min(1).max(90).optional(),
+  frequencyCapDays: z11.number().int().min(1).max(90).optional(),
+  objective: z11.enum([
+    "REACH",
+    "BRAND_AWARENESS",
+    "VIDEO_VIEWS",
+    "POST_ENGAGEMENT",
+    "LINK_CLICKS",
+    "OUTCOME_AWARENESS",
+    "OUTCOME_ENGAGEMENT"
+  ]).default("REACH"),
+  /**
+   * Balanced frequency (`is_balanced_frequency` + `target_frequency`): Meta
+   * aims each person at this many views per `targetFrequencyDays` rather than
+   * capping. Live on v26.0 (2026-10-15) it quoted only under
+   * OUTCOME_AWARENESS / OUTCOME_ENGAGEMENT with a REACH or THRUPLAY goal
+   * ("Target frequency can only be used when…"), and a plain quote without it
+   * needs a frequency cap.
+   */
+  targetFrequency: z11.number().int().min(1).max(90).optional(),
+  targetFrequencyDays: z11.number().int().min(1).max(90).optional(),
+  optimization_goal: z11.string().min(1).max(64).optional(),
+  /** The Page (and Instagram account) the ads run as. */
+  page_id: z11.string().regex(NUMERIC_ID_REGEX),
+  instagram_user_id: z11.string().regex(NUMERIC_ID_REGEX).optional(),
+  /** Meta targeting: ONE country, no website custom audiences. */
+  targeting: z11.record(z11.string(), z11.unknown()),
+  /**
+   * Run only in these hours (`day_parting_schedule`): minutes from midnight
+   * and days (0 = Sunday). Live on v26.0 (2026-10-15) a weekday 09–18 quote
+   * came back with its own reach.
+   */
+  day_parting_schedule: z11.array(
+    z11.strictObject({
+      start_minute: z11.number().int().min(0).max(1440),
+      end_minute: z11.number().int().min(0).max(1440),
+      days: z11.array(z11.number().int().min(0).max(6)).min(1)
+    })
+  ).min(1).optional(),
+  /** In-stream video content packages the ads may run in (`instream_packages`). */
+  instream_packages: z11.array(z11.enum(INSTREAM_PACKAGES)).min(1).optional()
+}).superRefine((p, ctx) => {
+  if (p.solveFor === "reach" && p.budget === void 0) {
+    ctx.addIssue({ code: "custom", path: ["budget"], message: "solving for reach needs --budget" });
+  }
+  if (p.solveFor === "budget" && p.reach === void 0) {
+    ctx.addIssue({ code: "custom", path: ["reach"], message: "solving for budget needs --reach" });
+  }
+  if (p.end_time <= p.start_time) {
+    ctx.addIssue({ code: "custom", path: ["end_time"], message: "the end comes after the start" });
+  }
+  if (p.targetFrequency !== void 0) {
+    const objectiveOk = p.objective === "OUTCOME_AWARENESS" || p.objective === "OUTCOME_ENGAGEMENT";
+    const goalOk = p.optimization_goal === "REACH" || p.optimization_goal === "THRUPLAY";
+    if (!objectiveOk || !goalOk) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["targetFrequency"],
+        message: "balanced frequency needs --objective OUTCOME_AWARENESS (or OUTCOME_ENGAGEMENT) and --optimization-goal REACH (or THRUPLAY)"
+      });
+    }
+  }
+  if (p.end_time - p.start_time > 90 * 86400) {
+    ctx.addIssue({ code: "custom", path: ["end_time"], message: "Meta reserves at most 90 days" });
+  }
+});
+var reachFrequencyReservationCreateSchema = z11.strictObject({
+  prediction_id: z11.string().regex(NUMERIC_ID_REGEX)
+});
+var reachFrequencyReservationUpdateSchema = z11.strictObject({ status: z11.literal("CANCELLED") });
+
+// ../api/src/ads-meta/ops.ts
+var tempRefSchema3 = z12.string().regex(TEMP_REF_REGEX, "expected a meta_temp_* reference");
+var parentRefSchema = z12.union([z12.string().regex(NUMERIC_ID_REGEX, "expected a numeric id"), tempRefSchema3]);
+var moneySchema = z12.strictObject({
+  amount: z12.string().regex(/^\d+(\.\d{1,2})?$/, "expected a decimal amount like 50 or 50.00").refine((val) => Number(val) > 0, "amount must be greater than zero"),
+  currencyCode: z12.string().length(3).optional()
+});
+var httpsUrlSchema5 = z12.string().url().refine((u) => u.startsWith("https://"), "destination URLs must be https");
+var bakerMediaIdSchema = z12.string().min(1);
+var stageableStatusSchema = z12.enum(STAGEABLE_CREATE_STATUSES);
+var updateStatusSchema = z12.enum(UPDATE_STATUSES);
+var labelFields = {
+  adlabels: z12.array(parentRefSchema).max(META_LIMITS.adLabel.perObjectMax).optional(),
+  addLabels: z12.array(parentRefSchema).min(1).optional(),
+  removeLabels: z12.array(parentRefSchema).min(1).optional()
+};
+var createLabelFields = { adlabels: labelFields.adlabels };
+function currencyMinimums(currencyCode) {
+  return CURRENCY_MINIMUMS[currencyCode] ?? DEFAULT_CURRENCY_MINIMUM;
+}
+function validateDailyBudgetFloor(money, ctx, path) {
+  if (money?.currencyCode) {
+    const min = currencyMinimums(money.currencyCode).dailyBudgetMin;
+    if (Number(money.amount) < min) {
+      ctx.addIssue({ code: "custom", path, message: `below the ${min} ${money.currencyCode} daily minimum` });
+    }
+  }
+}
+var geoLocationsSchema = z12.object({
+  countries: z12.array(z12.string().length(2)).optional(),
+  regions: z12.array(z12.object({ key: z12.string() })).optional(),
+  cities: z12.array(z12.object({ key: z12.string(), radius: z12.number().optional(), distance_unit: z12.string().optional() })).optional(),
+  zips: z12.array(z12.object({ key: z12.string() })).optional(),
+  location_types: z12.array(z12.string()).optional()
+}).catchall(z12.unknown());
+var idNameSchema = z12.object({ id: z12.string(), name: z12.string().optional() });
+var productAudienceEventSchema = z12.strictObject({
+  retention_seconds: z12.number().int().min(3600).max(180 * 86400),
+  rule: z12.record(z12.string(), z12.unknown()).refine((rule) => JSON.stringify(rule).includes('"event"'), {
+    message: 'a product audience rule names the event it counts, e.g. {"event":{"eq":"ViewContent"}}'
+  })
+});
+var productAudienceSpecSchema = z12.strictObject({
+  /** A product set's id, or the meta_temp_* ref of one this chat creates. */
+  product_set_id: parentRefSchema,
+  inclusions: z12.array(productAudienceEventSchema).min(1),
+  exclusions: z12.array(productAudienceEventSchema).min(1).optional()
+});
+var metaTargetingSchema = z12.object({
+  geo_locations: geoLocationsSchema.optional(),
+  excluded_geo_locations: geoLocationsSchema.optional(),
+  age_min: z12.number().int().min(13).max(65).optional(),
+  age_max: z12.number().int().min(13).max(65).optional(),
+  genders: z12.array(z12.union([z12.literal(1), z12.literal(2)])).optional(),
+  locales: z12.array(z12.number().int()).optional(),
+  interests: z12.array(idNameSchema).optional(),
+  behaviors: z12.array(idNameSchema).optional(),
+  custom_audiences: z12.array(z12.object({ id: parentRefSchema })).optional(),
+  excluded_custom_audiences: z12.array(z12.object({ id: parentRefSchema })).optional(),
+  flexible_spec: z12.array(z12.record(z12.string(), z12.unknown())).optional(),
+  product_audience_specs: z12.array(productAudienceSpecSchema).min(1).optional(),
+  excluded_product_audience_specs: z12.array(productAudienceSpecSchema).min(1).optional(),
+  /**
+   * Retired by Meta: live on v25.0 (2026-10-14) a create excluding one
+   * interest was refused — "Detailed targeting exclusions are no longer
+   * available for ad sets" (subcode 3858492). Excluding people goes through
+   * `excluded_custom_audiences`.
+   */
+  exclusions: z12.record(z12.string(), z12.unknown()).refine((value) => Object.keys(value).length === 0, {
+    message: "Meta no longer lets an ad set exclude detailed targeting (interests, behaviors, demographics) \u2014 take targeting.exclusions out; to keep people out, exclude a custom audience (excluded_custom_audiences)"
+  }).optional(),
+  publisher_platforms: z12.array(z12.string()).optional(),
+  facebook_positions: z12.array(z12.string()).optional(),
+  instagram_positions: z12.array(z12.string()).optional(),
+  audience_network_positions: z12.array(z12.string()).optional(),
+  messenger_positions: z12.array(z12.string()).optional(),
+  threads_positions: z12.array(z12.string()).optional(),
+  device_platforms: z12.array(z12.string()).optional(),
+  targeting_automation: z12.object({ advantage_audience: z12.union([z12.literal(0), z12.literal(1)]) }).partial().optional(),
+  ...brandSafetyTargetingFields
+}).catchall(z12.unknown());
+var GEO_INCLUSION_KEYS = [
+  "countries",
+  "country_groups",
+  "regions",
+  "cities",
+  "zips",
+  "geo_markets",
+  "places",
+  "custom_locations",
+  "electoral_districts",
+  "subcities",
+  "neighborhoods",
+  "subneighborhoods",
+  "metro_areas",
+  "large_geo_areas",
+  "medium_geo_areas",
+  "small_geo_areas"
+];
+function targetingHasGeo(t) {
+  const geo = t?.geo_locations;
+  return Boolean(
+    geo && GEO_INCLUSION_KEYS.some((key) => Array.isArray(geo[key]) && geo[key].length > 0)
+  );
+}
+function targetingHasGeoOrAudience(t) {
+  if (!t) {
+    return false;
+  }
+  return targetingHasGeo(t) || Boolean(t.custom_audiences?.length);
+}
+function advantageAudienceSetting(t) {
+  const value = t.targeting_automation?.advantage_audience;
+  return value === 0 || value === 1 ? value : void 0;
+}
+function targetingHardLimitsDemographics(t) {
+  if (!t) {
+    return false;
+  }
+  const narrowsAgeMax = typeof t.age_max === "number" && t.age_max < ADVANTAGE_AUDIENCE_OPEN_AGE_MAX;
+  const narrowsAgeMin = typeof t.age_min === "number" && t.age_min > ADVANTAGE_AUDIENCE_MAX_HARD_AGE_MIN;
+  const narrowsGender = Array.isArray(t.genders) && t.genders.length === 1;
+  return narrowsAgeMax || narrowsAgeMin || narrowsGender;
+}
+var QUARTER_HOUR_MS = 15 * 6e4;
+var MIN_HIGH_DEMAND_PERIOD_MS = 3 * 36e5;
+var budgetScheduleSchema = z12.strictObject({
+  time_start: z12.number().int().positive(),
+  time_end: z12.number().int().positive(),
+  increase: moneySchema.optional(),
+  increasePercent: z12.number().int().min(1).max(800).optional()
+}).superRefine((period, ctx) => {
+  if (period.increase === void 0 === (period.increasePercent === void 0)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["increase"],
+      message: "a budget schedule raises the budget by an amount (increase) or a percentage (increasePercent) \u2014 one of them"
+    });
+  }
+  if (period.time_end - period.time_start < MIN_HIGH_DEMAND_PERIOD_MS) {
+    ctx.addIssue({ code: "custom", path: ["time_end"], message: "a high-demand period lasts at least 3 hours" });
+  }
+  if (period.time_start % QUARTER_HOUR_MS !== 0 || period.time_end % QUARTER_HOUR_MS !== 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["time_start"],
+      message: "Meta starts and ends a high-demand period on a quarter hour (:00, :15, :30 or :45)"
+    });
+  }
+});
+var budgetSchedulesSchema = z12.array(budgetScheduleSchema).min(1).max(META_LIMITS.adSet.budgetSchedulesMax).refine(
+  (periods) => new Set(periods.map((period) => period.increase === void 0)).size <= 1,
+  "Meta raises a budget by amounts or by percentages, not both \u2014 use one kind for every period"
+);
+function validateBudgetSchedules(p, ctx) {
+  if (p.budgetSchedules && !p.dailyBudget) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["budgetSchedules"],
+      message: "a budget schedule raises a daily budget, and Meta needs that daily budget in the same change \u2014 pass dailyBudget (the current one, on an update)"
+    });
+  }
+}
+var boostMoveSchema = z12.strictObject({
+  id: z12.string().regex(NUMERIC_ID_REGEX, "a boost is named by its id from `baker ads meta high-demand-periods`"),
+  time_start: z12.number().int().positive(),
+  time_end: z12.number().int().positive(),
+  increase: moneySchema.optional(),
+  increasePercent: z12.number().int().min(1).max(800).optional()
+}).superRefine((move, ctx) => {
+  if (move.increase !== void 0 && move.increasePercent !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["increase"],
+      message: "a boost raises the budget by an amount or by a percentage, not both \u2014 a move keeps the live boost's own"
+    });
+  }
+  if (move.time_end - move.time_start < MIN_HIGH_DEMAND_PERIOD_MS) {
+    ctx.addIssue({ code: "custom", path: ["time_end"], message: "a high-demand period lasts at least 3 hours" });
+  }
+  if (move.time_start % QUARTER_HOUR_MS !== 0 || move.time_end % QUARTER_HOUR_MS !== 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["time_start"],
+      message: "Meta starts and ends a high-demand period on a quarter hour (:00, :15, :30 or :45)"
+    });
+  }
+});
+var boostEditFields = {
+  removeBoosts: z12.array(z12.string().regex(NUMERIC_ID_REGEX, "a boost is named by its id from `baker ads meta high-demand-periods`")).min(1).max(META_LIMITS.adSet.budgetSchedulesMax).optional(),
+  moveBoosts: z12.array(boostMoveSchema).min(1).max(META_LIMITS.adSet.budgetSchedulesMax).optional()
+};
+function validateBoostEdits(p, ctx) {
+  const removed = new Set(p.removeBoosts ?? []);
+  for (const move of p.moveBoosts ?? []) {
+    if (removed.has(move.id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["moveBoosts"],
+        message: `boost ${move.id} is both moved and removed \u2014 pick one`
+      });
+    }
+  }
+  if (p.clear?.includes("budgetSchedules") && (p.removeBoosts || p.moveBoosts)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["clear"],
+      message: "clearing every boost already removes the ones named \u2014 drop removeBoosts/moveBoosts or the clear"
+    });
+  }
+}
+var specialAdCategoriesSchema = z12.array(z12.enum(SPECIAL_AD_CATEGORIES)).default(["NONE"]);
+var campaignCreateSchema = z12.strictObject({
+  name: z12.string().min(1).max(META_LIMITS.campaign.nameMax),
+  objective: z12.enum(OBJECTIVES),
+  status: stageableStatusSchema.default("PAUSED"),
+  special_ad_categories: specialAdCategoriesSchema,
+  special_ad_category_country: z12.array(z12.string().length(2)).optional(),
+  buying_type: z12.enum(BUYING_TYPES).default("AUCTION"),
+  bid_strategy: z12.enum(BID_STRATEGIES).optional(),
+  /** Campaign Budget Optimization (Advantage campaign budget) — mutually exclusive with ad-set budgets. */
+  dailyBudget: moneySchema.optional(),
+  lifetimeBudget: moneySchema.optional(),
+  spendCap: moneySchema.optional(),
+  /**
+   * Ad-set budget sharing: lets ad sets lend up to 20% of their budget to each
+   * other. Meta requires an explicit true/false on any campaign that carries no
+   * campaign budget (subcode 4834011); Baker sends false unless asked, because
+   * turning it on moves real spend between ad sets nobody asked to move.
+   */
+  adSetBudgetSharing: z12.boolean().optional(),
+  budgetSchedules: budgetSchedulesSchema.optional(),
+  start_time: z12.number().int().positive().optional(),
+  stop_time: z12.number().int().positive().optional(),
+  /**
+   * Advantage+ catalog ads: the catalog the campaign sells from. Meta fixes it
+   * at creation; each ad set then names one of its product sets.
+   */
+  promoted_object: z12.strictObject({ product_catalog_id: parentRefSchema }).optional(),
+  ...createLabelFields
+}).superRefine((p, ctx) => {
+  if (p.dailyBudget && p.lifetimeBudget) {
+    ctx.addIssue({ code: "custom", path: ["dailyBudget"], message: "set only one of dailyBudget or lifetimeBudget" });
+  }
+  validateDailyBudgetFloor(p.dailyBudget, ctx, ["dailyBudget", "amount"]);
+  validateBudgetSchedules(p, ctx);
+  if (p.stop_time && p.start_time && p.stop_time <= p.start_time) {
+    ctx.addIssue({ code: "custom", path: ["stop_time"], message: "stop_time must be after start_time" });
+  }
+  const needsCountry = p.special_ad_categories.some((c) => SPECIAL_CATEGORIES_REQUIRING_COUNTRY.includes(c));
+  if (needsCountry && !p.special_ad_category_country?.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["special_ad_category_country"],
+      message: "ISSUES_ELECTIONS_POLITICS campaigns need special_ad_category_country \u2014 pass the 2-letter country code(s) the ads run in"
+    });
+  }
+  const euCountries = (p.special_ad_category_country ?? []).filter((c) => EU_DSA_COUNTRIES.has(c.toUpperCase()));
+  if (needsCountry && euCountries.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["special_ad_category_country"],
+      message: `Meta no longer runs ads about social issues, elections or politics in the EU (since 6 October 2025), so it refuses this campaign for ${euCountries.join(", ")} \u2014 drop the EU countries, or run these ads outside Meta`
+    });
+  }
+});
+var AD_SET_CLEARABLE_CONTROLS = [
+  "dailyMinSpendTarget",
+  "dailySpendCap",
+  "lifetimeMinSpendTarget",
+  "lifetimeSpendCap",
+  "adset_schedule",
+  "budgetSchedules"
+];
+var CAMPAIGN_CLEARABLE_CONTROLS = ["budgetSchedules"];
+function validateClear(p, ctx) {
+  for (const field of p.clear ?? []) {
+    if (p[field] !== void 0) {
+      ctx.addIssue({ code: "custom", path: ["clear"], message: `${field} is both set and cleared \u2014 pick one` });
+    }
+  }
+}
+var campaignUpdateSchema = z12.strictObject({
+  name: z12.string().min(1).max(META_LIMITS.campaign.nameMax).optional(),
+  status: updateStatusSchema.optional(),
+  bid_strategy: z12.enum(BID_STRATEGIES).optional(),
+  dailyBudget: moneySchema.optional(),
+  lifetimeBudget: moneySchema.optional(),
+  spendCap: moneySchema.optional(),
+  budgetSchedules: budgetSchedulesSchema.optional(),
+  start_time: z12.number().int().positive().optional(),
+  stop_time: z12.number().int().positive().optional(),
+  /** Budget boosts to take away — every one the campaign had when this was staged. */
+  clear: z12.array(z12.enum(CAMPAIGN_CLEARABLE_CONTROLS)).min(1).optional(),
+  ...boostEditFields,
+  ...labelFields
+}).superRefine((p, ctx) => {
+  if (!Object.values(p).some((val) => val !== void 0)) {
+    ctx.addIssue({ code: "custom", message: "update needs at least one field" });
+  }
+  if (p.dailyBudget && p.lifetimeBudget) {
+    ctx.addIssue({ code: "custom", path: ["dailyBudget"], message: "set only one of dailyBudget or lifetimeBudget" });
+  }
+  validateDailyBudgetFloor(p.dailyBudget, ctx, ["dailyBudget", "amount"]);
+  validateBudgetSchedules(p, ctx);
+  validateClear(p, ctx);
+  validateBoostEdits(p, ctx);
+});
+var promotedObjectFields = {
+  page_id: parentRefSchema.optional(),
+  pixel_id: z12.string().regex(NUMERIC_ID_REGEX).optional(),
+  custom_event_type: z12.enum(CUSTOM_EVENT_TYPES).optional(),
+  /**
+   * A Custom Conversion to optimize toward, instead of a raw pixel event.
+   * Named alone by the caller: the stage reads the conversion off Meta and
+   * fills `pixel_id`, `custom_event_type` and `pixel_rule` from it, so the
+   * staged payload matches what Ads Manager stores and the review shows the
+   * event the ad set will actually chase.
+   */
+  custom_conversion_id: z12.union([z12.string().regex(NUMERIC_ID_REGEX), tempRefSchema3]).optional(),
+  /** The custom conversion's own filter, filled by the stage. Never written by hand. */
+  pixel_rule: z12.string().optional(),
+  application_id: z12.string().regex(NUMERIC_ID_REGEX).optional(),
+  object_store_url: z12.string().url().optional(),
+  product_catalog_id: parentRefSchema.optional(),
+  /** A product set's id, or the meta_temp_* ref of one this chat creates. */
+  product_set_id: parentRefSchema.optional(),
+  whatsapp_phone_number: z12.string().optional(),
+  offline_conversion_data_set_id: z12.string().regex(NUMERIC_ID_REGEX).optional()
+};
+var promotedObjectSchema = z12.strictObject(promotedObjectFields, {
+  error: (issue) => issue.code === "unrecognized_keys" ? `promoted_object does not take ${issue.keys.map((key) => `"${key}"`).join(", ")} \u2014 it takes ${Object.keys(promotedObjectFields).join(", ")}` : void 0
+});
+var attributionSpecSchema = z12.array(
+  z12.strictObject({
+    event_type: z12.enum(ATTRIBUTION_EVENT_TYPES),
+    window_days: z12.union([z12.literal(1), z12.literal(7)])
+  }).refine((w) => w.window_days <= ATTRIBUTION_MAX_WINDOW_DAYS[w.event_type], {
+    error: "Meta counts a view or an engaged video view for 1 day only \u2014 window_days 1",
+    path: ["window_days"]
+  })
+);
+var minRoasSchema = z12.number().min(META_LIMITS.adSet.minRoasMin, `minRoas must be at least ${META_LIMITS.adSet.minRoasMin} (Meta's floor)`).max(META_LIMITS.adSet.minRoasMax, `minRoas must be at most ${META_LIMITS.adSet.minRoasMax} (Meta's ceiling)`).refine(
+  (roas) => Math.round(roas * ROAS_FLOOR_SCALE) / ROAS_FLOOR_SCALE === roas,
+  "Meta keeps a minimum ROAS to 4 decimals (2.3333, not 2.33333)"
+);
+var frequencyCapSchema = z12.strictObject({
+  event: z12.enum(FREQUENCY_CAP_EVENTS).default("IMPRESSIONS"),
+  interval_days: z12.number().int().min(1).max(META_LIMITS.adSet.frequencyIntervalDaysMax),
+  max_frequency: z12.number().int().min(1).max(META_LIMITS.adSet.frequencyMaxImpressionsMax),
+  type: z12.enum(FREQUENCY_CAP_TYPES).optional()
+});
+var spendLimitFields = {
+  dailyMinSpendTarget: moneySchema.optional(),
+  dailySpendCap: moneySchema.optional(),
+  lifetimeMinSpendTarget: moneySchema.optional(),
+  lifetimeSpendCap: moneySchema.optional()
+};
+function minAboveCap(min, cap) {
+  return min !== void 0 && cap !== void 0 && Number(min.amount) > Number(cap.amount);
+}
+function validateSpendLimits(p, ctx) {
+  const daily = p.dailyMinSpendTarget !== void 0 || p.dailySpendCap !== void 0;
+  const lifetime = p.lifetimeMinSpendTarget !== void 0 || p.lifetimeSpendCap !== void 0;
+  if ((daily || lifetime) && (p.dailyBudget || p.lifetimeBudget)) {
+    ctx.addIssue({
+      code: "custom",
+      path: [daily ? "dailySpendCap" : "lifetimeSpendCap"],
+      message: "spend limits share out a campaign budget \u2014 an ad set with its own budget takes none; drop the budget or the limits"
+    });
+  }
+  if (daily && lifetime) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["lifetimeSpendCap"],
+      message: "use daily limits under a daily campaign budget and lifetime limits under a lifetime one, never both"
+    });
+  }
+  if (minAboveCap(p.dailyMinSpendTarget, p.dailySpendCap) || minAboveCap(p.lifetimeMinSpendTarget, p.lifetimeSpendCap)) {
+    ctx.addIssue({
+      code: "custom",
+      path: [daily ? "dailyMinSpendTarget" : "lifetimeMinSpendTarget"],
+      message: "the minimum spend can't be higher than the spend cap"
+    });
+  }
+}
+var MINUTES_PER_DAY2 = 24 * 60;
+var scheduleBlockSchema = z12.strictObject({
+  start_minute: z12.number().int().min(0).max(MINUTES_PER_DAY2),
+  end_minute: z12.number().int().min(0).max(MINUTES_PER_DAY2),
+  days: z12.array(z12.number().int().min(0).max(6)).min(1),
+  timezone_type: z12.enum(SCHEDULE_TIMEZONE_TYPES).optional()
+}).superRefine((block, ctx) => {
+  if (block.start_minute % 60 !== 0 || block.end_minute % 60 !== 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["start_minute"],
+      message: "Meta schedules whole hours \u2014 start_minute and end_minute must be multiples of 60 (540 = 9:00)"
+    });
+  }
+  if (block.end_minute - block.start_minute < 60) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["end_minute"],
+      message: "a schedule block must end at least one hour after it starts"
+    });
+  }
+});
+var adSetFields = {
+  name: z12.string().min(1).max(META_LIMITS.adSet.nameMax),
+  campaign_id: parentRefSchema,
+  status: stageableStatusSchema.default("PAUSED"),
+  dailyBudget: moneySchema.optional(),
+  lifetimeBudget: moneySchema.optional(),
+  bidAmount: moneySchema.optional(),
+  bid_strategy: z12.enum(BID_STRATEGIES).optional(),
+  minRoas: minRoasSchema.optional(),
+  frequency_control_specs: z12.array(frequencyCapSchema).min(1).optional(),
+  adset_schedule: z12.array(scheduleBlockSchema).min(1).optional(),
+  pacing: z12.enum(PACING_TYPES).optional(),
+  ...spendLimitFields,
+  /**
+   * Create-only on an ad set. Meta refuses `budget_schedule_specs` on an ad set
+   * update even beside its daily budget ("Ad set must have daily budget to
+   * support budget schedule", subcode 3858199 — live on v25.0, 2026-10-14);
+   * only the `/budget_schedules` edge adds one later, and that edge ignores
+   * `validate_only` (a dry run created a real period), so Baker does not use it.
+   */
+  budgetSchedules: budgetSchedulesSchema.optional(),
+  /**
+   * A Dynamic Creative ad set: its one ad mixes the images, videos and texts of
+   * an asset-feed (`dynamic`) creative. Create-only — Meta fixes it for the ad
+   * set's life — and such an ad set holds exactly one ad (subcode 1885553).
+   */
+  is_dynamic_creative: z12.boolean().optional(),
+  /**
+   * Reach and frequency: the reservation this ad set is bought on (its id, or
+   * the meta_temp_* ref of a `reachFrequencyReservation.create` in this chat).
+   * Its campaign is `buying_type: RESERVED` (`reachFrequency.ts`).
+   */
+  rf_prediction_id: parentRefSchema.optional(),
+  billing_event: z12.enum(BILLING_EVENTS),
+  optimization_goal: z12.enum(OPTIMIZATION_GOALS),
+  destination_type: z12.enum(DESTINATION_TYPES).optional(),
+  promoted_object: promotedObjectSchema.optional(),
+  attribution_spec: attributionSpecSchema.optional(),
+  start_time: z12.number().int().positive().optional(),
+  end_time: z12.number().int().positive().optional(),
+  targeting: metaTargetingSchema,
+  /**
+   * The live ad set this one was copied from, verbatim, by `duplicate`. Baker
+   * only — `adSetCommonBody` never sends it to Meta. Set exclusively when the
+   * targeting IS the source's targeting, because that is what it licenses:
+   * placement validation is skipped for it (see `validateAdSetPlacements`).
+   */
+  clonedFrom: z12.string().regex(NUMERIC_ID_REGEX).optional(),
+  /** EU Digital Services Act: who benefits from / pays for the ad. Auto-filled from the account for EU geo when omitted. */
+  dsa_beneficiary: z12.string().min(1).max(100).optional(),
+  dsa_payor: z12.string().min(1).max(100).optional(),
+  /** Advantage+ placements with limited spend — Sales and Leads campaigns only (`adSetCompliance.ts`). */
+  placement_soft_opt_out: placementSoftOptOutSchema.optional(),
+  ...regionalRegulationFields,
+  ...createLabelFields
+};
+var MIN_ROAS = "LOWEST_COST_WITH_MIN_ROAS";
+function validateMinRoas(p, ctx, requireFloor) {
+  if (p.minRoas !== void 0 && p.bid_strategy !== void 0 && p.bid_strategy !== MIN_ROAS) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["minRoas"],
+      message: `minRoas only works with bid_strategy ${MIN_ROAS} \u2014 Meta refuses a ROAS floor beside ${p.bid_strategy}`
+    });
+  }
+  if (requireFloor && p.bid_strategy === MIN_ROAS && p.minRoas === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["minRoas"],
+      message: `${MIN_ROAS} needs minRoas \u2014 the return every euro spent must average, e.g. 2.5 for 250% (--min-roas 2.5)`
+    });
+  }
+}
+var ONE_DAY_CLICK_GOALS = /* @__PURE__ */ new Set(["LINK_CLICKS", "LANDING_PAGE_VIEWS", "REACH"]);
+function validateAttribution(p, ctx) {
+  const goal = p.optimization_goal;
+  if (!p.attribution_spec || !goal || !ONE_DAY_CLICK_GOALS.has(goal)) return;
+  const oneDayClick = p.attribution_spec.every((w) => w.event_type === "CLICK_THROUGH" && w.window_days === 1);
+  if (!oneDayClick) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["attribution_spec"],
+      message: `Meta attributes a ${goal} ad set on a 1-day click only \u2014 use --attribution 1d_click, or leave it out`
+    });
+  }
+}
+function validateFrequencyCap(p, ctx) {
+  const goal = p.optimization_goal;
+  if (p.frequency_control_specs && goal && !OPTIMIZATION_GOALS_WITH_FREQUENCY_CAP.includes(goal)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["frequency_control_specs"],
+      message: `Meta caps frequency only on ${OPTIMIZATION_GOALS_WITH_FREQUENCY_CAP.join(" or ")} ad sets, not ${goal}`
+    });
+  }
+  if (!p.rf_prediction_id && (p.frequency_control_specs ?? []).some((cap) => cap.type === "TARGET")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["frequency_control_specs"],
+      message: "Meta takes a TARGET frequency only on a reach-and-frequency ad set with a prediction attached (subcode 3858652) \u2014 use a CAP (leave type out)"
+    });
+  }
+  const events = (p.frequency_control_specs ?? []).map((cap) => cap.event);
+  if (events.includes("VIDEO_VIEWS")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["frequency_control_specs"],
+      message: "Meta fails a VIDEO_VIEWS frequency cap with an unknown error \u2014 count VIDEO_VIEWS_2S or VIDEO_VIEWS_15S, or IMPRESSIONS"
+    });
+  }
+  if (events.includes("VIDEO_VIEWS_6S") && goal && goal !== "REACH") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["frequency_control_specs"],
+      message: `Meta counts VIDEO_VIEWS_6S caps on REACH ad sets only, not ${goal} \u2014 use VIDEO_VIEWS_2S or VIDEO_VIEWS_15S`
+    });
+  }
+}
+function validatePacing(p, ctx) {
+  if (p.adset_schedule && p.pacing !== void 0 && p.pacing !== "day_parting") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["pacing"],
+      message: `an ad schedule runs only with day_parting pacing, not ${p.pacing} \u2014 drop pacing and Baker sends day_parting`
+    });
+  }
+  if (p.adset_schedule && p.dailyBudget) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["adset_schedule"],
+      message: "Meta runs an ad schedule only on a lifetime budget \u2014 use lifetimeBudget with an end_time"
+    });
+  }
+  if (p.pacing === "day_parting" && !p.adset_schedule) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["pacing"],
+      message: "day_parting pacing needs adset_schedule \u2014 the hours the ads may run"
+    });
+  }
+  if (p.pacing === "no_pacing" && p.bid_strategy !== void 0 && p.bid_strategy !== "LOWEST_COST_WITH_BID_CAP") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["pacing"],
+      message: `accelerated delivery (no_pacing) works only with LOWEST_COST_WITH_BID_CAP, not ${p.bid_strategy}`
+    });
+  }
+}
+function validateBidStrategy(p, ctx) {
+  const strategy = p.bid_strategy;
+  if (!strategy) {
+    return;
+  }
+  if (BID_STRATEGIES_REQUIRING_AMOUNT.includes(strategy) && !p.bidAmount) {
+    ctx.addIssue({ code: "custom", path: ["bidAmount"], message: `${strategy} requires a bidAmount` });
+  }
+  if (BID_STRATEGIES_FORBIDDING_AMOUNT.includes(strategy) && p.bidAmount) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["bidAmount"],
+      message: `${strategy} must not set a bidAmount \u2014 Meta rejects one (it bids automatically)`
+    });
+  }
+  if (strategy === "COST_CAP" && p.billing_event && p.billing_event !== "IMPRESSIONS") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["billing_event"],
+      message: "COST_CAP requires billing_event IMPRESSIONS"
+    });
+  }
+  if (strategy === "LOWEST_COST_WITH_MIN_ROAS" && p.optimization_goal && p.optimization_goal !== "VALUE") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["bid_strategy"],
+      message: "LOWEST_COST_WITH_MIN_ROAS requires optimization_goal VALUE"
+    });
+  }
+}
+function validateAdSetBudgetAndBid(p, ctx) {
+  if (p.dailyBudget && p.lifetimeBudget) {
+    ctx.addIssue({ code: "custom", path: ["dailyBudget"], message: "set only one of dailyBudget or lifetimeBudget" });
+  }
+  validateDailyBudgetFloor(p.dailyBudget, ctx, ["dailyBudget", "amount"]);
+  if (p.lifetimeBudget && !p.end_time) {
+    ctx.addIssue({ code: "custom", path: ["end_time"], message: "lifetimeBudget ad sets need an end_time" });
+  }
+  validateBidStrategy(p, ctx);
+  if (p.end_time && p.start_time && p.end_time <= p.start_time) {
+    ctx.addIssue({ code: "custom", path: ["end_time"], message: "end_time must be after start_time" });
+  }
+}
+function validateAdSetPromotedObject(p, ctx) {
+  const goal = p.optimization_goal;
+  if (!goal) {
+    return;
+  }
+  const po = p.promoted_object;
+  const namesConversion = Boolean(po?.custom_conversion_id);
+  const hasPixel = Boolean(po?.pixel_id) || namesConversion || Boolean(po?.product_set_id);
+  const hasEventType = Boolean(po?.custom_event_type) || namesConversion;
+  if (OPTIMIZATION_GOALS_REQUIRING_PAGE.includes(goal) && !po?.page_id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["promoted_object", "page_id"],
+      message: `optimization_goal ${goal} needs promoted_object.page_id \u2014 pass --page-id with the Facebook Page the leads/likes belong to`
+    });
+  }
+  if (OPTIMIZATION_GOALS_REQUIRING_PIXEL.includes(goal) && !hasPixel) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["promoted_object", "pixel_id"],
+      message: `optimization_goal ${goal} needs promoted_object.pixel_id \u2014 pass --pixel-id with the conversion pixel, or --custom-conversion-id to optimize toward a custom conversion`
+    });
+  }
+  if (OPTIMIZATION_GOALS_REQUIRING_CONVERSION_SOURCE.includes(goal) && !hasPixel && !po?.application_id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["promoted_object", "pixel_id"],
+      message: `optimization_goal ${goal} needs a conversion source \u2014 pass promoted_object.pixel_id (web value optimization) or promoted_object.application_id (app value optimization)`
+    });
+  }
+  if ((OPTIMIZATION_GOALS_REQUIRING_PIXEL.includes(goal) || OPTIMIZATION_GOALS_REQUIRING_CONVERSION_SOURCE.includes(goal)) && !hasEventType) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["promoted_object", "custom_event_type"],
+      message: `optimization_goal ${goal} needs promoted_object.custom_event_type \u2014 pass --custom-event-type (e.g. PURCHASE, LEAD), or --custom-conversion-id to optimize toward a custom conversion`
+    });
+  }
+  if (OPTIMIZATION_GOALS_REQUIRING_APP.includes(goal) && !po?.application_id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["promoted_object", "application_id"],
+      message: `optimization_goal ${goal} needs promoted_object.application_id`
+    });
+  }
+}
+function validateMessagingAdSet(p, ctx) {
+  const opensConversation = MESSAGING_DESTINATION_TYPES.some((type) => type === p.destination_type);
+  if (opensConversation && !p.promoted_object?.page_id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["promoted_object", "page_id"],
+      message: `destination_type ${p.destination_type} opens a conversation with a Page \u2014 pass promoted_object.page_id (--page-id) with that Page`
+    });
+  }
+  if (p.optimization_goal === "CONVERSATIONS" && p.destination_type !== void 0 && !opensConversation) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["destination_type"],
+      message: `optimization_goal CONVERSATIONS needs destination_type MESSENGER, WHATSAPP, INSTAGRAM_DIRECT or a MESSAGING_* mix \u2014 ${p.destination_type} opens no conversation`
+    });
+  }
+  if (p.optimization_goal === "CONVERSATIONS" && p.destination_type === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["destination_type"],
+      message: "optimization_goal CONVERSATIONS needs destination_type MESSENGER, WHATSAPP, INSTAGRAM_DIRECT or a MESSAGING_* mix \u2014 where the conversation opens"
+    });
+  }
+}
+function validateAdvantageAudience(p, ctx) {
+  const t = p.targeting;
+  if (t && targetingHardLimitsDemographics(t) && advantageAudienceSetting(t) === 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["targeting", "targeting_automation", "advantage_audience"],
+      message: "Advantage+ Audience (advantage_audience: 1) treats age and gender as suggestions, so a hard age/gender limit is rejected \u2014 set advantage_audience: 0 to enforce the limit, or drop the age_max/age_min/gender restriction"
+    });
+  }
+}
+function validateAdSetPlacements(p, ctx) {
+  if (p.clonedFrom) {
+    for (const issue of invalidPlacementValues(p.targeting)) {
+      if (issue.kind === "retired") {
+        ctx.addIssue({
+          code: "custom",
+          path: ["targeting", issue.field],
+          message: `${issue.field} no longer accepts "${issue.value}". ${issue.fix} (${PLACEMENT_TARGETING_DOC})`
+        });
+      }
+    }
+    return;
+  }
+  const missingFeed = positionsMissingRequiredFeed(p.targeting);
+  if (missingFeed.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["targeting", "facebook_positions"],
+      message: `Meta requires "feed" alongside ${missingFeed.join(", ")} \u2014 add "feed" to facebook_positions or drop those positions (${PLACEMENT_TARGETING_DOC})`
+    });
+  }
+  for (const issue of invalidPlacementValues(p.targeting)) {
+    if (issue.kind === "unknown") {
+      continue;
+    }
+    ctx.addIssue({
+      code: "custom",
+      path: ["targeting", issue.field],
+      message: issue.kind === "retired" ? `${issue.field} no longer accepts "${issue.value}". ${issue.fix} (${PLACEMENT_TARGETING_DOC})` : `${issue.field} does not accept "${issue.value}". ${issue.fix} (${PLACEMENT_TARGETING_DOC})`
+    });
+  }
+  for (const message of placementCoRequirementIssues(p.targeting)) {
+    ctx.addIssue({ code: "custom", path: ["targeting"], message: `${message} (${PLACEMENT_TARGETING_DOC})` });
+  }
+}
+function validateSoftOptOut(p, ctx, isCreate) {
+  const issue = softOptOutPlacementIssue(
+    p.placement_soft_opt_out,
+    p.targeting,
+    isCreate
+  );
+  if (issue) ctx.addIssue({ code: "custom", path: ["placement_soft_opt_out"], message: issue });
+}
+var adSetCreateSchema = z12.strictObject(adSetFields).superRefine((p, ctx) => {
+  validateAdSetBudgetAndBid(p, ctx);
+  validateMinRoas(p, ctx, true);
+  validateFrequencyCap(p, ctx);
+  validateAttribution(p, ctx);
+  validatePacing(p, ctx);
+  validateSpendLimits(p, ctx);
+  validateBudgetSchedules(p, ctx);
+  validateAdSetPromotedObject(p, ctx);
+  validateMessagingAdSet(p, ctx);
+  validateAdvantageAudience(p, ctx);
+  validateAdSetPlacements(p, ctx);
+  validateRegionalRegulation(p, ctx);
+  validateSoftOptOut(p, ctx, true);
+  if (!targetingHasGeoOrAudience(p.targeting)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["targeting", "geo_locations"],
+      message: 'targeting needs a location \u2014 set targeting.geo_locations (e.g. countries: ["US"]) or include a custom audience; Meta rejects an ad set with no geo'
+    });
+  }
+});
+var adSetUpdateSchema = z12.strictObject({
+  name: adSetFields.name.optional(),
+  status: updateStatusSchema.optional(),
+  dailyBudget: moneySchema.optional(),
+  lifetimeBudget: moneySchema.optional(),
+  bidAmount: moneySchema.optional(),
+  bid_strategy: z12.enum(BID_STRATEGIES).optional(),
+  minRoas: minRoasSchema.optional(),
+  frequency_control_specs: z12.array(frequencyCapSchema).min(1).optional(),
+  adset_schedule: z12.array(scheduleBlockSchema).min(1).optional(),
+  pacing: z12.enum(PACING_TYPES).optional(),
+  ...spendLimitFields,
+  optimization_goal: z12.enum(OPTIMIZATION_GOALS).optional(),
+  destination_type: z12.enum(DESTINATION_TYPES).optional(),
+  promoted_object: promotedObjectSchema.optional(),
+  attribution_spec: attributionSpecSchema.optional(),
+  start_time: z12.number().int().positive().optional(),
+  end_time: z12.number().int().positive().optional(),
+  targeting: metaTargetingSchema.optional(),
+  dsa_beneficiary: z12.string().min(1).max(100).optional(),
+  dsa_payor: z12.string().min(1).max(100).optional(),
+  placement_soft_opt_out: placementSoftOptOutSchema.optional(),
+  ...regionalRegulationFields,
+  /**
+   * Boosts ADDED to a live ad set. Meta refuses `budget_schedule_specs` in an
+   * ad set update (subcode 3858199) but takes each period on the
+   * `/{adset}/budget_schedules` edge without the budget restated (live on
+   * v26.0, 2026-10-15), so the executor sends them there.
+   */
+  budgetSchedules: budgetSchedulesSchema.optional(),
+  /** Delivery controls to take away (`AD_SET_CLEARABLE_CONTROLS`). */
+  clear: z12.array(z12.enum(AD_SET_CLEARABLE_CONTROLS)).min(1).optional(),
+  ...boostEditFields,
+  ...labelFields
+}).superRefine((p, ctx) => {
+  if (!Object.values(p).some((val) => val !== void 0)) {
+    ctx.addIssue({ code: "custom", message: "update needs at least one field" });
+  }
+  validateClear(p, ctx);
+  validateBoostEdits(p, ctx);
+  validateAdSetBudgetAndBid(p, ctx);
+  validateMinRoas(p, ctx, false);
+  validateFrequencyCap(p, ctx);
+  validateAttribution(p, ctx);
+  validatePacing(p, ctx);
+  validateSpendLimits(p, ctx);
+  if (p.optimization_goal) {
+    validateAdSetPromotedObject(p, ctx);
+  }
+  if (p.destination_type) {
+    validateMessagingAdSet(p, ctx);
+  }
+  validateAdvantageAudience(p, ctx);
+  validateAdSetPlacements(p, ctx);
+  validateRegionalRegulation(p, ctx);
+  validateSoftOptOut(p, ctx, false);
+});
+var messageSchema = z12.string().min(1).max(META_LIMITS.creative.messageHardMax);
+var headlineSchema = z12.string().min(1).max(META_LIMITS.creative.headlineMax);
+var descriptionSchema = z12.string().min(1).max(META_LIMITS.creative.descriptionMax);
+var callToActionSchema = z12.strictObject({
+  type: z12.enum(CTA_TYPES),
+  /** Overrides the base link for the CTA button; defaults to the ad's link. */
+  link: httpsUrlSchema5.optional(),
+  /**
+   * The instant form the button opens — Meta's `call_to_action.value.lead_gen_form_id`.
+   * This is the ONLY place an instant form is named: the ad set says leads open
+   * on the ad (`destination_type: ON_AD`), and the creative says which form.
+   * Without it Meta refuses every ad in that ad set with subcode 3390001,
+   * "Choose or create an instant form for your leads campaign".
+   */
+  lead_gen_form_id: parentRefSchema.optional(),
+  /** The app a click-to-message button opens a conversation in — `value.app_destination`. */
+  app_destination: z12.enum(APP_DESTINATIONS).optional(),
+  /**
+   * App ads: the deep link the button opens in an installed app (`value.app_link`,
+   * e.g. `myapp://product/12`). Meta refuses one without an app-store `link`
+   * beside it (subcode 1885949, live on v25.0, 2026-10-15).
+   */
+  app_link: z12.string().min(3).max(1e3).optional(),
+  /**
+   * App ads: the Meta app the button installs or opens (`value.application`).
+   * Meta refuses one whose store does not match the button's link (subcode
+   * 1885270, live on v25.0, 2026-10-15).
+   */
+  application: z12.string().regex(NUMERIC_ID_REGEX).optional()
+}).superRefine((p, ctx) => {
+  validateMessagingButton(p, ctx);
+  if (p.lead_gen_form_id && !LEAD_FORM_CTA_TYPES.some((allowed) => allowed === p.type)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["type"],
+      message: `${p.type} cannot open an instant form \u2014 Meta refuses it (subcode 1856030). Use one of ${LEAD_FORM_CTA_TYPES.join(", ")}, or drop lead_gen_form_id if this ad should go to the website.`
+    });
+  }
+});
+function validateMessagingButton(p, ctx) {
+  const opens = MESSAGING_CTA_DESTINATION[p.type];
+  if (opens && p.app_destination && p.app_destination !== opens) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["app_destination"],
+      message: `${p.type} opens ${opens} \u2014 set app_destination ${opens}, or pick the button of ${p.app_destination}`
+    });
+  }
+  if (p.app_destination && p.lead_gen_form_id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["app_destination"],
+      message: "a button opens a conversation or an instant form, not both \u2014 drop app_destination or lead_gen_form_id"
+    });
+  }
+}
+var creativeEnhancementsSchema = z12.strictObject({
+  standardEnhancements: z12.enum(ENROLL_STATUSES).optional(),
+  features: z12.record(z12.string(), z12.enum(ENROLL_STATUSES)).optional()
+});
+var multiAdvertiserSchema = z12.enum(["opt_in", "opt_out"]);
+var partnerSchema = z12.strictObject({
+  facebook_page_id: z12.string().regex(NUMERIC_ID_REGEX).optional(),
+  instagram_user_id: z12.string().regex(NUMERIC_ID_REGEX).optional(),
+  ad_format: z12.enum(["both", "first_only", "auto"]).optional()
+}).refine(
+  (p) => p.facebook_page_id !== void 0 || p.instagram_user_id !== void 0,
+  "name the partner's Page or Instagram account"
+);
+var creativeSharedFields = {
+  name: z12.string().max(META_LIMITS.creative.nameMax).optional(),
+  /** Facebook Page id backing the ad's identity. */
+  page_id: parentRefSchema,
+  /** Instagram account id for IG placements (aka instagram_actor_id on read). */
+  instagram_user_id: z12.string().regex(NUMERIC_ID_REGEX).optional(),
+  /** URL tracking parameters appended to the destination, e.g. "utm_source=fb&utm_campaign=x". */
+  url_tags: z12.string().max(1e3).optional(),
+  enhancements: creativeEnhancementsSchema.optional(),
+  /**
+   * v26: on an advertiser with a shop, Meta sends eligible new ads to the shop
+   * as well as the website (`destination_spec` WEBSITE_AND_SHOP) unless told
+   * not to. `website_only` opts out (WEBSITE_AND_SHOP_OPT_OUT); unset leaves
+   * Meta's default. Live on v26.0: both values validate, any other is refused.
+   */
+  shop_destination: z12.enum(["website_and_shop", "website_only"]).optional(),
+  multi_advertiser: multiAdvertiserSchema.optional(),
+  partner: partnerSchema.optional()
+};
+var conversationAndAppFields = {
+  welcome_message: welcomeMessageSchema.optional(),
+  /**
+   * How a deep link opens: `deeplink_with_web_fallback` (the app, else the
+   * website), `deeplink_with_appstore_fallback` (the app, else its store page),
+   * `web_only`, or `automatic` (Meta decides).
+   */
+  applink_treatment: z12.enum(["automatic", "deeplink_with_web_fallback", "deeplink_with_appstore_fallback", "web_only"]).optional()
+};
+var imageMediaFields = {
+  imageHash: z12.string().regex(IMAGE_HASH_REGEX).optional(),
+  imageRef: tempRefSchema3.optional()
+};
+var videoMediaFields = {
+  videoId: z12.string().regex(NUMERIC_ID_REGEX).optional(),
+  videoRef: tempRefSchema3.optional(),
+  /** The video's cover: a picture already in the ad account, by hash. */
+  thumbnailHash: z12.string().regex(IMAGE_HASH_REGEX).optional(),
+  /** The video's cover: a library picture staged as a `media upload --kind image` in this chat. */
+  thumbnailRef: tempRefSchema3.optional(),
+  /** The video's cover: a public picture URL Meta fetches. */
+  imageUrl: z12.string().url().optional()
+};
+function validateDeepLink(cta, creativeLink, ctx, path) {
+  if (!cta?.app_link) return;
+  const link = cta.link ?? creativeLink;
+  if (!link || !isAppStoreUrl(link)) {
+    ctx.addIssue({
+      code: "custom",
+      path,
+      message: `a deep link (app_link) needs the button to lead to the app's store page \u2014 Meta refuses it beside ${link ?? "no link"} (subcode 1885949); set the link to the App Store or Google Play URL`
+    });
+  }
+}
+function isAppStoreUrl(url) {
+  try {
+    const host = new URL(url).hostname.toLowerCase();
+    return ["apps.apple.com", "itunes.apple.com", "play.google.com"].includes(host);
+  } catch {
+    return false;
+  }
+}
+function validateWelcomeOpensConversation(p, ctx) {
+  if (p.welcome_message && !p.call_to_action?.app_destination) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["welcome_message"],
+      message: "a greeting needs a button that opens a conversation \u2014 set call_to_action.app_destination (MESSENGER, WHATSAPP or INSTAGRAM_DIRECT)"
+    });
+  }
+}
+function countImageRefs(p) {
+  return [p.imageHash, p.imageRef].filter(Boolean).length;
+}
+function countVideoRefs(p) {
+  return [p.videoId, p.videoRef].filter(Boolean).length;
+}
+var singleCreativeSchema = z12.strictObject({
+  creativeType: z12.literal("single"),
+  ...creativeSharedFields,
+  /** Primary text. */
+  message: messageSchema,
+  link: httpsUrlSchema5,
+  /** Headline. */
+  headline: headlineSchema.optional(),
+  description: descriptionSchema.optional(),
+  /** Display URL / caption shown under the headline. */
+  caption: z12.string().max(255).optional(),
+  call_to_action: callToActionSchema.optional(),
+  ...imageMediaFields,
+  ...videoMediaFields,
+  ...conversationAndAppFields
+}).superRefine((p, ctx) => {
+  validateWelcomeOpensConversation(p, ctx);
+  validateDeepLink(p.call_to_action, p.link, ctx, ["call_to_action", "app_link"]);
+  const images = countImageRefs(p);
+  const videos = countVideoRefs(p);
+  if (images + videos === 0) {
+    ctx.addIssue({ code: "custom", path: ["imageHash"], message: "a single ad needs one image or one video" });
+  }
+  if (images > 1) {
+    ctx.addIssue({ code: "custom", path: ["imageHash"], message: "provide exactly one image reference" });
+  }
+  if (videos > 1) {
+    ctx.addIssue({ code: "custom", path: ["videoId"], message: "provide exactly one video reference" });
+  }
+  if (images > 0 && videos > 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["videoId"],
+      message: "a single ad is either an image OR a video, not both"
+    });
+  }
+});
+var carouselCardSchema = z12.strictObject({
+  link: httpsUrlSchema5,
+  headline: z12.string().max(META_LIMITS.creative.headlineMax).optional(),
+  description: z12.string().max(META_LIMITS.creative.descriptionMax).optional(),
+  call_to_action: callToActionSchema.optional(),
+  ...imageMediaFields,
+  ...videoMediaFields
+}).superRefine((p, ctx) => {
+  const images = countImageRefs(p);
+  const videos = countVideoRefs(p);
+  if (images + videos === 0) {
+    ctx.addIssue({ code: "custom", path: ["imageHash"], message: "each card needs an image or a video" });
+  }
+  if (images > 1) {
+    ctx.addIssue({ code: "custom", path: ["imageHash"], message: "each card needs exactly one image reference" });
+  }
+  if (videos > 1) {
+    ctx.addIssue({ code: "custom", path: ["videoId"], message: "each card needs exactly one video reference" });
+  }
+  if (images > 0 && videos > 0) {
+    ctx.addIssue({ code: "custom", path: ["videoId"], message: "each card is an image OR a video, not both" });
+  }
+});
+var carouselCreativeSchema = z12.strictObject({
+  creativeType: z12.literal("carousel"),
+  ...creativeSharedFields,
+  message: messageSchema,
+  /** Optional "see more" card destination applied when a card has no own link. */
+  link: httpsUrlSchema5.optional(),
+  call_to_action: callToActionSchema.optional(),
+  cards: z12.array(carouselCardSchema).min(META_LIMITS.creative.carouselCardsMin).max(META_LIMITS.creative.carouselCardsMax),
+  /**
+   * `multi_share_optimized`. Meta's default (`optimized`) reorders the cards
+   * by performance and may show only the top five; `fixed` — Baker's default —
+   * shows every card in the order it was built.
+   */
+  card_order: z12.enum(["fixed", "optimized"]).default("fixed"),
+  /** `multi_share_end_card`: Meta adds a card linking to the Page after the last one. Off unless asked. */
+  end_card: z12.boolean().default(false),
+  ...conversationAndAppFields
+}).superRefine((p, ctx) => {
+  validateWelcomeOpensConversation(p, ctx);
+  validateDeepLink(p.call_to_action, p.link ?? p.cards[0]?.link, ctx, ["call_to_action", "app_link"]);
+  p.cards.forEach((card, index) => {
+    validateDeepLink(card.call_to_action, card.link, ctx, ["cards", index, "call_to_action", "app_link"]);
+  });
+  const forms = new Set(
+    [p.call_to_action?.lead_gen_form_id, ...p.cards.map((card) => card.call_to_action?.lead_gen_form_id)].filter(
+      Boolean
+    )
+  );
+  if (forms.size > 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["cards"],
+      message: `every card of a carousel must open the SAME instant form \u2014 this one names ${[...forms].join(" and ")}`
+    });
+  }
+});
+var dynamicImageSchema = z12.strictObject({ ...imageMediaFields }).refine((p) => countImageRefs(p) === 1, "each dynamic image needs exactly one reference");
+var dynamicVideoSchema = z12.strictObject({
+  videoId: videoMediaFields.videoId,
+  videoRef: videoMediaFields.videoRef,
+  thumbnailHash: videoMediaFields.thumbnailHash,
+  thumbnailRef: videoMediaFields.thumbnailRef
+}).refine((p) => countVideoRefs(p) === 1, "each dynamic video needs exactly one reference");
+var DYN = META_LIMITS.creative;
+function assetFeedCount(p) {
+  return p.bodies.length + p.titles.length + (p.descriptions?.length ?? 0) + (p.images?.length ?? 0) + (p.videos?.length ?? 0) + p.link_urls.length + (p.call_to_action_types?.length ?? 0) + 1;
+}
+var dynamicCreativeSchema = z12.strictObject({
+  creativeType: z12.literal("dynamic"),
+  ...creativeSharedFields,
+  bodies: z12.array(z12.strictObject({ text: z12.string().min(1).max(DYN.assetFeedBodyMax) })).min(DYN.dynamicTextsMin).max(DYN.dynamicTextsMax),
+  titles: z12.array(z12.strictObject({ text: z12.string().min(1).max(DYN.assetFeedTitleMax) })).min(DYN.dynamicTextsMin).max(DYN.dynamicTextsMax),
+  descriptions: z12.array(z12.strictObject({ text: z12.string().min(1).max(DYN.assetFeedTitleMax) })).max(DYN.dynamicTextsMax).optional(),
+  images: z12.array(dynamicImageSchema).max(DYN.assetFeedImagesMax).optional(),
+  videos: z12.array(dynamicVideoSchema).max(DYN.assetFeedVideosMax).optional(),
+  /**
+   * Exactly one format ("Only one ad_format is allowed per asset feed").
+   * Meta's doc calls it required; when it is left out the builder fills it
+   * from the media (`AUTOMATIC_FORMAT` for pictures and videos together) —
+   * except on a flexible (`DEGREES_OF_FREEDOM`) creative, every one of which
+   * read back off a live account omits it.
+   */
+  ad_formats: z12.array(z12.enum(AD_FORMATS)).length(1).optional(),
+  call_to_action_types: z12.array(z12.string()).max(DYN.dynamicTextsMax).optional(),
+  /**
+   * The button on the creative's own `link_data` — a flexible ad carries both
+   * envelopes, and this is the one that takes `SEE_DETAILS`. Kept separate
+   * from `call_to_action_types` because Meta validates the two against
+   * different enums.
+   */
+  call_to_action: callToActionSchema.optional(),
+  link_urls: z12.array(z12.strictObject({ website_url: httpsUrlSchema5, display_url: z12.string().optional() })).min(1).max(DYN.dynamicTextsMax),
+  /**
+   * `asset_feed_spec.optimization_type` — passed through as a free string on
+   * purpose. Meta's own 400 enumerates ten values and then accepts
+   * `DEGREES_OF_FREEDOM`, which is not among them and is what every
+   * Advantage+ flexible creative on a live account reports. An enum here
+   * would refuse the value Meta itself hands back.
+   */
+  optimization_type: z12.string().optional(),
+  /** Multi-language / placement customization — structural passthrough for v1. */
+  asset_customization_rules: z12.array(z12.record(z12.string(), z12.unknown())).optional()
+}).superRefine((p, ctx) => {
+  if (!(p.images?.length || p.videos?.length)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["images"],
+      message: "a dynamic creative needs at least one image or video"
+    });
+  }
+  const assets = assetFeedCount(p);
+  if (assets > DYN.assetFeedAssetsMax) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["images"],
+      message: `a dynamic creative carries at most ${DYN.assetFeedAssetsMax} assets in all (pictures, videos, texts, links, buttons and the format each count) \u2014 this has ${assets}`
+    });
+  }
+  p.call_to_action_types?.forEach((type, index) => {
+    if (ASSET_FEED_CTA_TYPES.some((allowed) => allowed === type)) {
+      return;
+    }
+    const isLinkButton = CTA_TYPES.some((allowed) => allowed === type);
+    ctx.addIssue({
+      code: "custom",
+      path: ["call_to_action_types", index],
+      message: isLinkButton ? `${type} is not one of the buttons Meta accepts in asset_feed_spec.call_to_action_types \u2014 it is a link_data button. Pass it as call_to_action: { type: "${type}" } instead.` : `${type} is not a Meta call-to-action button.`
+    });
+  });
+});
+var placementAssetSchema = z12.strictObject({
+  ...imageMediaFields,
+  ...videoMediaFields,
+  placements: z12.array(z12.enum(PLACEMENT_SLOTS)).min(1)
+}).superRefine((p, ctx) => {
+  const images = countImageRefs(p);
+  const videos = countVideoRefs(p);
+  if (images + videos !== 1) {
+    ctx.addIssue({ code: "custom", path: ["imageRef"], message: "each asset is exactly one picture or one video" });
+  }
+  if (p.placements.includes("default") && p.placements.length > 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["placements"],
+      message: '"default" already means every placement no other asset names \u2014 give it alone'
+    });
+  }
+});
+var placementCreativeSchema = z12.strictObject({
+  creativeType: z12.literal("placement"),
+  ...creativeSharedFields,
+  message: z12.string().min(1).max(META_LIMITS.creative.assetFeedBodyMax),
+  link: httpsUrlSchema5,
+  headline: z12.string().min(1).max(META_LIMITS.creative.assetFeedTitleMax).optional(),
+  description: z12.string().min(1).max(META_LIMITS.creative.assetFeedTitleMax).optional(),
+  call_to_action: callToActionSchema.optional(),
+  assets: z12.array(placementAssetSchema).min(2).max(META_LIMITS.creative.assetFeedImagesMax)
+}).superRefine((p, ctx) => {
+  const carried = ["lead_gen_form_id", "link", "app_destination", "app_link", "application"].filter(
+    (key) => p.call_to_action?.[key] !== void 0
+  );
+  if (carried.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["call_to_action"],
+      message: `a placement creative's button is its type only \u2014 Meta keeps no ${carried.join(", ")} on it. For an Instant Form, a different button link or a messaging app, use a single or carousel creative`
+    });
+  }
+  const defaults = p.assets.filter((asset) => asset.placements.includes("default")).length;
+  if (defaults !== 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["assets"],
+      message: `exactly one asset must be "default" \u2014 the one every other placement shows (this has ${defaults})`
+    });
+  }
+  const claimed = /* @__PURE__ */ new Map();
+  p.assets.forEach((asset, index) => {
+    for (const slot of asset.placements) {
+      if (slot !== "default" && claimed.has(slot)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["assets", index, "placements"],
+          message: `${slot} is already given to asset ${claimed.get(slot)} \u2014 one asset per placement`
+        });
+      }
+      claimed.set(slot, index);
+    }
+  });
+  const kinds = new Set(p.assets.map((asset) => countVideoRefs(asset) > 0 ? "video" : "image"));
+  if (kinds.size > 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["assets"],
+      message: "every asset of a placement creative is a picture, or every one is a video \u2014 Meta takes one format per ad"
+    });
+  }
+});
+var existingPostCreativeSchema = z12.strictObject({
+  creativeType: z12.literal("existing_post"),
+  name: creativeSharedFields.name,
+  /** "<page_id>_<post_id>" object story id of the Facebook post to promote. */
+  object_story_id: z12.string().regex(/^\d+_\d+$/, 'expected "<page_id>_<post_id>"').optional(),
+  /** An Instagram post's media id — from `baker ads meta instagram-media`. */
+  source_instagram_media_id: z12.string().regex(NUMERIC_ID_REGEX).optional(),
+  /** A creator's partnership ad code for their Instagram post. */
+  instagram_ad_code: z12.string().trim().min(8).max(500).optional(),
+  /** The brand's Page the ad runs as — needed with an Instagram post or an ad code. */
+  page_id: z12.string().regex(NUMERIC_ID_REGEX).optional(),
+  instagram_user_id: creativeSharedFields.instagram_user_id,
+  url_tags: creativeSharedFields.url_tags,
+  enhancements: creativeSharedFields.enhancements,
+  multi_advertiser: creativeSharedFields.multi_advertiser,
+  partner: creativeSharedFields.partner
+}).superRefine((p, ctx) => {
+  const sources = [p.object_story_id, p.source_instagram_media_id, p.instagram_ad_code].filter(Boolean).length;
+  if (sources !== 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["object_story_id"],
+      message: "boost ONE post: object_story_id (Facebook), source_instagram_media_id (Instagram) or instagram_ad_code"
+    });
+  }
+  if ((p.source_instagram_media_id || p.instagram_ad_code) && !p.page_id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["page_id"],
+      message: "an Instagram post runs as the brand's Facebook Page \u2014 add page_id"
+    });
+  }
+});
+var specCreativeSchema = z12.strictObject({
+  creativeType: z12.literal("spec"),
+  name: creativeSharedFields.name,
+  url_tags: creativeSharedFields.url_tags,
+  /** Promote the existing post — keeps the ad's likes, comments and shares. */
+  object_story_id: z12.string().regex(/^\d+_\d+$/, 'expected "<page_id>_<post_id>"').optional(),
+  object_story_spec: z12.record(z12.string(), z12.unknown()).optional(),
+  asset_feed_spec: z12.record(z12.string(), z12.unknown()).optional(),
+  degrees_of_freedom_spec: z12.record(z12.string(), z12.unknown()).optional(),
+  instagram_user_id: creativeSharedFields.instagram_user_id,
+  /** The creative this spec was cloned from, for the review diff. */
+  clonedFrom: z12.string().regex(NUMERIC_ID_REGEX).optional()
+}).superRefine((p, ctx) => {
+  if (!(p.object_story_id || p.object_story_spec || p.asset_feed_spec)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["object_story_spec"],
+      message: "a spec creative needs object_story_id, object_story_spec or asset_feed_spec"
+    });
+  }
+});
+var CATALOG_TOKEN_NAMESPACES = [
+  "product",
+  "category",
+  "hotel",
+  "flight",
+  "destination",
+  "home_listing",
+  "vehicle",
+  "vehicle_offer",
+  "trip"
+];
+function unknownCatalogTokens(text) {
+  return [...(text ?? "").matchAll(/\{\{\s*([^}|\s]+)[^}]*\}\}/g)].filter((match) => !CATALOG_TOKEN_NAMESPACES.some((ns) => match[1]?.startsWith(`${ns}.`))).map((match) => match[0]);
+}
+var templateText = (max) => z12.string().trim().min(1).max(max);
+var catalogCreativeSchema = z12.strictObject({
+  creativeType: z12.literal("catalog"),
+  name: creativeSharedFields.name,
+  page_id: creativeSharedFields.page_id,
+  instagram_user_id: creativeSharedFields.instagram_user_id,
+  url_tags: creativeSharedFields.url_tags,
+  /** A product set's id, or the meta_temp_* ref of one this chat creates. */
+  product_set_id: parentRefSchema,
+  message: templateText(META_LIMITS.creative.messageHardMax),
+  link: httpsUrlSchema5,
+  headline: templateText(255).optional(),
+  description: templateText(255).optional(),
+  call_to_action: z12.strictObject({ type: z12.enum(CTA_TYPES) }).optional(),
+  /**
+   * `carousel` (Meta picks the products, one card each — the default),
+   * `single` (one product per ad: `force_single_link`), or `slideshow` (each
+   * card cycles a product's pictures: `format_option: carousel_slideshows`).
+   */
+  format: z12.enum(["carousel", "single", "slideshow"]).default("carousel"),
+  /** `multi_share_end_card`: a last card linking to the Page. Off unless asked. */
+  end_card: z12.boolean().default(false)
+}).superRefine((p, ctx) => {
+  for (const key of ["message", "headline", "description"]) {
+    const unknown = unknownCatalogTokens(p[key]);
+    if (unknown.length > 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: [key],
+        message: `${unknown.join(", ")} reads no catalog field \u2014 a token names its catalog type, e.g. {{product.name}}, {{product.price}}`
+      });
+    }
+  }
+});
+var instantExperienceCreativeSchema = z12.strictObject({
+  creativeType: z12.literal("instant_experience"),
+  name: creativeSharedFields.name,
+  page_id: creativeSharedFields.page_id,
+  instagram_user_id: creativeSharedFields.instagram_user_id,
+  url_tags: creativeSharedFields.url_tags,
+  /** The experience: its id, or the meta_temp_* ref of one this chat creates. */
+  canvas_id: parentRefSchema,
+  message: messageSchema,
+  headline: headlineSchema.optional(),
+  description: descriptionSchema.optional(),
+  call_to_action: z12.strictObject({ type: z12.enum(CTA_TYPES) }).optional(),
+  format: z12.enum(["standard", "collection"]).default("standard"),
+  /**
+   * A collection over a photo experience (more than header → product set →
+   * footer) shows four pictures under its hero, named by the experience's
+   * elements: a photo element, or one product of a product-set element
+   * (`element_child_index`). Meta refuses such a collection without four
+   * (2131023). Only a live experience has element ids — read them with
+   * `instant-experiences --page-id`.
+   */
+  collection_thumbnails: z12.array(
+    z12.strictObject({
+      element_id: z12.string().regex(NUMERIC_ID_REGEX),
+      element_child_index: z12.number().int().min(0).optional(),
+      /**
+       * The square of a photo element shown, in the photo's pixels:
+       * `{"100x100": [[left, top], [right, bottom]]}` — Meta's only key.
+       * Required on a photo element (live); staging fills a centered
+       * square from the photo when it is left out.
+       */
+      element_crops: z12.strictObject({
+        "100x100": z12.tuple([
+          z12.tuple([z12.number().int().min(0), z12.number().int().min(0)]),
+          z12.tuple([z12.number().int().positive(), z12.number().int().positive()])
+        ])
+      }).optional()
+    })
+  ).length(4, "a collection shows exactly four pictures under its hero").optional(),
+  ...imageMediaFields,
+  ...videoMediaFields
+}).superRefine((p, ctx) => {
+  if (p.collection_thumbnails && (p.format !== "collection" || !NUMERIC_ID_REGEX.test(p.canvas_id))) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["collection_thumbnails"],
+      message: "collection thumbnails go on a --format collection ad over a live Instant Experience (its elements have ids only once it exists)"
+    });
+  }
+  const images = countImageRefs(p);
+  const videos = countVideoRefs(p);
+  if (images + videos !== 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["imageHash"],
+      message: "the ad shows one picture or one video before it opens the experience"
+    });
+  }
+});
+var creativeContentSchema = z12.discriminatedUnion("creativeType", [
+  singleCreativeSchema,
+  carouselCreativeSchema,
+  dynamicCreativeSchema,
+  placementCreativeSchema,
+  existingPostCreativeSchema,
+  specCreativeSchema,
+  catalogCreativeSchema,
+  instantExperienceCreativeSchema
+]);
+var adCreativeCreateSchema = creativeContentSchema;
+var adCreativeUpdateSchema = z12.strictObject({
+  name: z12.string().max(META_LIMITS.creative.nameMax).optional(),
+  status: z12.enum(CREATIVE_UPDATE_STATUSES).optional(),
+  /** Content patch — only honored when the target is a staged meta_temp_* creative. */
+  content: z12.record(z12.string(), z12.unknown()).optional(),
+  ...labelFields
+}).refine((p) => Object.values(p).some((val) => val !== void 0), "update needs at least one field");
+var adCreateSchema = z12.strictObject({
+  name: z12.string().min(1).max(META_LIMITS.ad.nameMax),
+  adset_id: parentRefSchema,
+  status: stageableStatusSchema.default("PAUSED"),
+  creative: z12.strictObject({ creative_id: parentRefSchema }),
+  /** Conversion pixel / offline event set / view tags — structural passthrough. */
+  tracking_specs: z12.array(z12.record(z12.string(), z12.unknown())).optional(),
+  /**
+   * The website domain the ad's conversions are counted on — the registrable
+   * domain only (`example.com`, never `www.example.com` or a URL). Meta fills
+   * it from the destination when left out; set it when the site and the
+   * pixel's domain differ. Create-only on Meta's ad reference.
+   */
+  conversion_domain: z12.string().trim().toLowerCase().regex(/^(?!www\.)[a-z0-9-]+(\.[a-z0-9-]+)+$/, "the domain alone, e.g. example.com (no www., no https://)").optional(),
+  ...createLabelFields
+});
+var adUpdateSchema = z12.strictObject({
+  name: z12.string().min(1).max(META_LIMITS.ad.nameMax).optional(),
+  status: updateStatusSchema.optional(),
+  /** Swapping the creative is the Meta way to "edit" an ad's creative. */
+  creative: z12.strictObject({ creative_id: parentRefSchema }).optional(),
+  tracking_specs: z12.array(z12.record(z12.string(), z12.unknown())).optional(),
+  ...labelFields
+}).refine((p) => Object.values(p).some((val) => val !== void 0), "update needs at least one field");
+var lookalikeRatioSchema = z12.number().min(0.01).max(0.2).refine(
+  (ratio) => Math.abs(Math.round(ratio * 100) - ratio * 100) < 1e-9,
+  "Meta sizes a lookalike in 1% steps (0.01\u20130.20)"
+);
+var lookalikeSpecSchema = z12.strictObject({
+  origin: z12.array(
+    z12.strictObject({
+      // An audience this chat creates holds nobody until it publishes and Meta
+      // matches it, and Meta refuses a lookalike of an empty seed (1713008).
+      id: z12.string().regex(
+        NUMERIC_ID_REGEX,
+        "a lookalike's seed must already hold people \u2014 an audience this chat creates is empty until it publishes and Meta matches it (up to a day); make the lookalike in a later chat"
+      )
+    })
+  ).min(1).max(1, "Meta builds a lookalike from one seed audience \u2014 make one lookalike per seed").optional(),
+  conversions_of: z12.array(z12.string().regex(NUMERIC_ID_REGEX, "a live campaign or ad set id")).min(1).max(10).optional(),
+  ratio: lookalikeRatioSchema,
+  starting_ratio: z12.number().min(0).max(0.19).refine(
+    (ratio) => Math.abs(Math.round(ratio * 100) - ratio * 100) < 1e-9,
+    "a band starts on a whole percent (0.00, 0.01, \u2026 0.19)"
+  ).optional(),
+  country: z12.string().length(2).optional(),
+  countries: z12.array(z12.string().length(2)).min(1).max(50).optional(),
+  allow_international_seeds: z12.boolean().optional()
+}).superRefine((spec, ctx) => {
+  if (spec.origin === void 0 === (spec.conversions_of === void 0)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["origin"],
+      message: "a lookalike has one seed: an audience (origin) or the people who converted in live campaigns or ad sets (conversions_of)"
+    });
+  }
+  if (!spec.country && !spec.countries) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["country"],
+      message: "a lookalike is found in a country \u2014 name one (country) or several (countries)"
+    });
+  }
+  if (spec.country && spec.countries) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["countries"],
+      message: "name one country or a list of countries, not both"
+    });
+  }
+  if (spec.starting_ratio !== void 0 && (spec.ratio === void 0 || spec.starting_ratio >= spec.ratio)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["starting_ratio"],
+      message: "starting_ratio begins a band that ends at ratio, so it needs a larger ratio (0.01 to 0.03 is the 1%\u20133% band)"
+    });
+  }
+});
+function valuesOfKey(node, key) {
+  if (Array.isArray(node)) return node.flatMap((entry) => valuesOfKey(entry, key));
+  if (!node || typeof node !== "object") return [];
+  const record = node;
+  return [
+    ...key in record ? [record[key]] : [],
+    ...Object.values(record).flatMap((value) => valuesOfKey(value, key))
+  ];
+}
+function mixedEventSourceTypes(rule) {
+  const types = valuesOfKey(rule, "event_sources").flatMap((sources) => Array.isArray(sources) ? sources : []).map((source) => source?.type).filter((type) => typeof type === "string");
+  const distinct = [...new Set(types)].sort();
+  return distinct.length > 1 ? distinct : [];
+}
+var customAudienceMemberSchema = z12.strictObject({
+  email: z12.string().min(1).optional(),
+  phone: z12.string().min(1).optional(),
+  /** Two-letter ISO country (US, GB) — Meta reads a phone without its country code against it. */
+  country: z12.string().min(1).optional()
+}).refine((m) => m.email !== void 0 || m.phone !== void 0, "each person needs an email or a phone");
+var customAudienceCreateSchema = z12.strictObject({
+  name: z12.string().min(1).max(META_LIMITS.audience.nameMax),
+  subtype: z12.enum(CUSTOM_AUDIENCE_SUBTYPES),
+  description: z12.string().max(500).optional(),
+  customer_file_source: z12.enum(CUSTOMER_FILE_SOURCES).optional(),
+  retention_days: z12.number().int().min(1).max(META_LIMITS.audience.retentionDaysMax).optional(),
+  lookalike_spec: lookalikeSpecSchema.optional(),
+  /** Website/engagement rule — structural passthrough validated by Meta. */
+  rule: z12.record(z12.string(), z12.unknown()).optional(),
+  /** The people of a customer list (subtype CUSTOM), uploaded right after the audience is created at publish. */
+  members: z12.array(customAudienceMemberSchema).min(1).max(META_LIMITS.audience.membersMax).optional(),
+  /**
+   * A value-based customer list: each person carries what they are worth
+   * (the LOOKALIKE_VALUE column), and a lookalike of it finds people like
+   * the most valuable ones. Fixed at creation.
+   */
+  is_value_based: z12.boolean().optional()
+}).superRefine((p, ctx) => {
+  if (p.members && p.subtype !== "CUSTOM") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["members"],
+      message: "only a customer list (subtype CUSTOM) is made of people you upload \u2014 drop members or use subtype CUSTOM"
+    });
+  }
+  if (p.members && p.is_value_based) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["members"],
+      message: "a value-based list needs a value for each person \u2014 create it without members, then use audiences members add with a LOOKALIKE_VALUE column"
+    });
+  }
+  if (p.is_value_based && (p.subtype !== "CUSTOM" || !p.customer_file_source)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["is_value_based"],
+      message: "a value-based audience is a customer list \u2014 subtype CUSTOM with customer_file_source"
+    });
+  }
+  if (p.subtype === "LOOKALIKE" && !p.lookalike_spec) {
+    ctx.addIssue({ code: "custom", path: ["lookalike_spec"], message: "LOOKALIKE audiences need a lookalike_spec" });
+  }
+  if ((p.subtype === "WEBSITE" || p.subtype === "ENGAGEMENT") && !p.rule) {
+    ctx.addIssue({ code: "custom", path: ["rule"], message: `${p.subtype} audiences need a rule (use --file)` });
+  }
+  if (p.rule && p.retention_days !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["retention_days"],
+      message: "a rule carries its own window in retention_seconds, so drop retention_days \u2014 Meta takes it only on a customer-file audience, and sending both leaves the review showing a window the audience will not have"
+    });
+  }
+  const mixed = mixedEventSourceTypes(p.rule);
+  if (mixed.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["rule"],
+      message: `one audience covers one kind of source, but this rule mixes ${mixed.join(" and ")} \u2014 split it into one audience per source`
+    });
+  }
+});
+var customAudienceUpdateSchema = z12.strictObject({
+  name: z12.string().min(1).max(META_LIMITS.audience.nameMax).optional(),
+  description: z12.string().max(500).optional(),
+  customer_file_source: z12.enum(CUSTOMER_FILE_SOURCES).optional(),
+  opt_out_link: httpsUrlSchema5.optional(),
+  rule: z12.record(z12.string(), z12.unknown()).optional(),
+  status: z12.literal("DELETED").optional()
+}).superRefine((p, ctx) => {
+  if (!Object.values(p).some((val) => val !== void 0)) {
+    ctx.addIssue({ code: "custom", message: "update needs at least one field" });
+  }
+  if (p.status === "DELETED" && Object.values(p).filter((val) => val !== void 0).length > 1) {
+    ctx.addIssue({ code: "custom", path: ["status"], message: "a deleted audience takes no other change" });
+  }
+  const mixed = mixedEventSourceTypes(p.rule);
+  if (mixed.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["rule"],
+      message: `one audience covers one kind of source, but this rule mixes ${mixed.join(" and ")} \u2014 split it into one audience per source`
+    });
+  }
+});
+var customConversionCreateSchema = z12.strictObject({
+  name: z12.string().min(1).max(META_LIMITS.customConversion.nameMax),
+  description: z12.string().max(META_LIMITS.customConversion.descriptionMax).optional(),
+  /** The pixel the conversion counts from — `event_source_id` on the wire. Baker never creates pixels, so this is always a real id. */
+  pixel_id: z12.string().regex(NUMERIC_ID_REGEX),
+  custom_event_type: z12.enum(CUSTOM_EVENT_TYPES),
+  /** Meta's filter JSON. Built by `buildCustomConversionRule` for the URL case. */
+  rule: z12.record(z12.string(), z12.unknown()),
+  /** What one conversion is worth, when the site cannot send a value with the event. */
+  default_conversion_value: z12.number().min(0).optional()
+}).superRefine((p, ctx) => {
+  const refusal = customConversionRuleRefusal(p.rule);
+  if (refusal) {
+    ctx.addIssue({ code: "custom", path: ["rule"], message: refusal });
+  }
+});
+var customConversionUpdateSchema = z12.strictObject({
+  name: z12.string().min(1).max(META_LIMITS.customConversion.nameMax).optional(),
+  description: z12.string().max(META_LIMITS.customConversion.descriptionMax).optional(),
+  default_conversion_value: z12.number().min(0).optional(),
+  status: z12.literal("DELETED").optional()
+}).superRefine((p, ctx) => {
+  const set = Object.values(p).filter((val) => val !== void 0);
+  if (set.length === 0) {
+    ctx.addIssue({ code: "custom", message: "update needs at least one field" });
+  }
+  if (p.status === "DELETED" && set.length > 1) {
+    ctx.addIssue({ code: "custom", path: ["status"], message: "a deleted conversion takes no other change" });
+  }
+});
+var adLabelCreateSchema = z12.strictObject({
+  name: z12.string().trim().min(1).max(META_LIMITS.adLabel.nameMax)
+});
+var adLabelUpdateSchema = z12.strictObject({
+  name: z12.string().trim().min(1).max(META_LIMITS.adLabel.nameMax).optional(),
+  status: z12.literal("DELETED").optional()
+}).refine((p) => p.name === void 0 !== (p.status === void 0), "rename the label or delete it \u2014 one of them");
+var mediaDeleteSchema = z12.strictObject({
+  imageHash: z12.string().regex(IMAGE_HASH_REGEX).optional(),
+  /**
+   * Or a video, taken out of the ad account's video library
+   * (`DELETE /act_<id>/advideos?video_id=`). Live on v26.0, `DELETE /{video_id}`
+   * was refused with the user token and the Page token alike (1363055 "You
+   * might not have permission to delete this video"), with `pages_manage_posts`
+   * granted; the library delete took it off the account.
+   */
+  videoId: z12.string().regex(NUMERIC_ID_REGEX).optional()
+}).refine((p) => p.imageHash === void 0 !== (p.videoId === void 0), "name imageHash OR videoId");
+var mediaUploadSchema = z12.strictObject({
+  kind: z12.enum(MEDIA_KINDS),
+  bakerImageId: bakerMediaIdSchema.optional(),
+  bakerVideoId: bakerMediaIdSchema.optional(),
+  /** Optional display name / filename hint. */
+  name: z12.string().max(255).optional()
+}).superRefine((p, ctx) => {
+  if (p.kind === "image" && !p.bakerImageId) {
+    ctx.addIssue({ code: "custom", path: ["bakerImageId"], message: "image uploads need a bakerImageId" });
+  }
+  if (p.kind === "video" && !p.bakerVideoId) {
+    ctx.addIssue({ code: "custom", path: ["bakerVideoId"], message: "video uploads need a bakerVideoId" });
+  }
+});
+var adAccountUpdateSchema = z12.strictObject({
+  name: z12.string().trim().min(1).max(100).optional(),
+  /** The account spending limit — spending stops when the account has spent this since it was set. */
+  spendCap: moneySchema.optional(),
+  /** `remove`: no limit at all. `reset`: start counting toward the limit again from zero. */
+  spendCapAction: z12.enum(["remove", "reset"]).optional(),
+  /**
+   * The EU (DSA) advertiser and payer every new ad set on the account starts
+   * with (`default_dsa_beneficiary` / `default_dsa_payor`). Meta keeps both or
+   * neither, and clears them with two empty strings (`clearDefaultDsa`).
+   * Written on the account node, which ignores `validate_only`.
+   */
+  defaultDsaBeneficiary: z12.string().trim().min(1).max(512).optional(),
+  defaultDsaPayor: z12.string().trim().min(1).max(512).optional(),
+  clearDefaultDsa: z12.literal(true).optional()
+}).superRefine((p, ctx) => {
+  const dsa = [p.defaultDsaBeneficiary, p.defaultDsaPayor].filter((value) => value !== void 0).length;
+  if (p.name === void 0 && p.spendCap === void 0 && p.spendCapAction === void 0 && dsa === 0 && !p.clearDefaultDsa) {
+    ctx.addIssue({
+      code: "custom",
+      message: "name, spendCap, spendCapAction, the default EU advertiser and payer, or clearDefaultDsa is required"
+    });
+  }
+  if (dsa === 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultDsaPayor"],
+      message: "Meta keeps the default EU advertiser and payer together \u2014 pass both (the same name when one business does both)"
+    });
+  }
+  if (dsa > 0 && p.clearDefaultDsa) {
+    ctx.addIssue({ code: "custom", path: ["clearDefaultDsa"], message: "set the defaults OR clear them, not both" });
+  }
+  if (p.spendCap !== void 0 && p.spendCapAction === "remove") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["spendCapAction"],
+      message: "set a spending limit OR remove it, not both"
+    });
+  }
+});
+var META_DRAFT_OP_KINDS = [
+  "campaign.create",
+  "campaign.update",
+  "adSet.create",
+  "adSet.update",
+  "adCreative.create",
+  "adCreative.update",
+  "ad.create",
+  "ad.update",
+  "customAudience.create",
+  "customAudience.update",
+  "customAudience.members",
+  "customConversion.create",
+  "customConversion.update",
+  "leadForm.create",
+  "leadForm.update",
+  "media.upload",
+  "media.delete",
+  "adLabel.create",
+  "adLabel.update",
+  "adRule.create",
+  "adRule.update",
+  "adStudy.create",
+  "adStudy.update",
+  "campaign.copy",
+  "adSet.copy",
+  "ad.copy",
+  "canvas.create",
+  "canvas.update",
+  "productCatalog.create",
+  "productCatalog.update",
+  "product.create",
+  "product.update",
+  "productSet.create",
+  "productSet.update",
+  "productFeed.create",
+  "productFeed.update",
+  "pagePhoto.create",
+  "pagePhoto.update",
+  "adAccount.update",
+  "publisherBlockList.create",
+  "publisherBlockList.update",
+  "reachFrequencyReservation.create",
+  "reachFrequencyReservation.update"
+];
+var metaDraftOpKindSchema = z12.enum(META_DRAFT_OP_KINDS);
+var accountIdSchema = z12.string().regex(NUMERIC_ID_REGEX, "accountId must be the bare numeric ad account id");
+var updateTargetSchema = z12.union([z12.string().regex(NUMERIC_ID_REGEX), tempRefSchema3]);
+function createOp(kind, payload) {
+  return z12.object({ kind: z12.literal(kind), accountId: accountIdSchema, payload });
+}
+function updateOp(kind, payload) {
+  return z12.object({ kind: z12.literal(kind), accountId: accountIdSchema, target: updateTargetSchema, payload });
+}
+function budgetUpdateOp(kind, payload) {
+  return updateOp(kind, payload).extend({ confirmBudgetIncrease: z12.boolean().optional() });
+}
+var metaDraftOpInputSchema = z12.discriminatedUnion("kind", [
+  createOp("campaign.create", campaignCreateSchema),
+  budgetUpdateOp("campaign.update", campaignUpdateSchema),
+  createOp("adSet.create", adSetCreateSchema),
+  budgetUpdateOp("adSet.update", adSetUpdateSchema),
+  createOp("adCreative.create", adCreativeCreateSchema),
+  updateOp("adCreative.update", adCreativeUpdateSchema),
+  createOp("ad.create", adCreateSchema),
+  updateOp("ad.update", adUpdateSchema),
+  createOp("customAudience.create", customAudienceCreateSchema),
+  updateOp("customAudience.update", customAudienceUpdateSchema),
+  createOp("customAudience.members", customAudienceMembersSchema),
+  createOp("customConversion.create", customConversionCreateSchema),
+  updateOp("customConversion.update", customConversionUpdateSchema),
+  createOp("leadForm.create", leadFormCreateSchema),
+  updateOp("leadForm.update", leadFormUpdateSchema),
+  createOp("media.upload", mediaUploadSchema),
+  createOp("media.delete", mediaDeleteSchema),
+  createOp("adLabel.create", adLabelCreateSchema),
+  updateOp("adLabel.update", adLabelUpdateSchema),
+  createOp("adRule.create", adRuleCreateSchema),
+  updateOp("adRule.update", adRuleUpdateSchema),
+  createOp("adStudy.create", adStudyCreateSchema),
+  updateOp("adStudy.update", adStudyUpdateSchema),
+  createOp("campaign.copy", campaignCopySchema),
+  createOp("adSet.copy", adSetCopySchema),
+  createOp("ad.copy", adCopySchema),
+  createOp("canvas.create", canvasCreateSchema),
+  updateOp("canvas.update", canvasUpdateSchema),
+  createOp("productCatalog.create", productCatalogCreateSchema),
+  updateOp("productCatalog.update", productCatalogUpdateSchema),
+  createOp("product.create", productCreateSchema),
+  updateOp("product.update", productUpdateSchema),
+  createOp("productSet.create", productSetCreateSchema),
+  updateOp("productSet.update", productSetUpdateSchema),
+  createOp("productFeed.create", productFeedCreateSchema),
+  updateOp("productFeed.update", productFeedUpdateSchema),
+  createOp("pagePhoto.create", pagePhotoCreateSchema),
+  updateOp("pagePhoto.update", pagePhotoUpdateSchema),
+  updateOp("adAccount.update", adAccountUpdateSchema),
+  createOp("publisherBlockList.create", publisherBlockListCreateSchema),
+  updateOp("publisherBlockList.update", publisherBlockListUpdateSchema),
+  createOp("reachFrequencyReservation.create", reachFrequencyReservationCreateSchema),
+  updateOp("reachFrequencyReservation.update", reachFrequencyReservationUpdateSchema)
+]);
+
+export {
+  buildCustomConversionRule,
+  isMetaLeadAdsRefusal,
+  FACEBOOK_PREVIEW_FORMATS,
+  INSTAGRAM_PREVIEW_FORMATS,
+  PLATFORM_SCOPED_POSITIONS,
+  previewFormatForPosition,
+  placementFormatNote,
+  brandSafetyTargetingFields,
+  retailerIdFilter,
+  CUSTOMER_LIST_KEYS,
+  UNHASHED_CUSTOMER_LIST_KEYS,
+  IDENTIFYING_CUSTOMER_LIST_KEYS,
+  CUSTOMER_LIST_BATCH_ROWS,
+  CUSTOMER_LIST_MAX_BATCHES,
+  customerListPreviewCell,
+  customerListBatchSchema,
+  customAudienceMembersSchema,
+  metaTargetingSchema,
+  metaDraftOpInputSchema
+};
+//# sourceMappingURL=chunk-Q3GSVLE5.js.map