@koda-sl/baker-cli 0.568.0 → 0.570.0

package/dist/chunk-NXNOXZGB.js

@@ -0,0 +1,2523 @@
+// ../api/src/ad-library/wire.ts
+import { z } from "zod";
+var adLibraryPlatformSchema = z.enum(["meta", "linkedin", "tiktok", "google"]);
+var adLifecycleStageSchema = z.enum([
+  "new",
+  "testing",
+  "proven",
+  "evergreen",
+  "killed_early",
+  "retired",
+  "unverified"
+]);
+var winnersHardFiltersSchema = z.object({
+  platform: z.array(z.string()).optional(),
+  format: z.array(z.string()).optional(),
+  winner_category: z.array(z.string()).optional(),
+  awareness_stage: z.array(z.string()).optional(),
+  country: z.array(z.string()).optional(),
+  language: z.array(z.string()).optional(),
+  advertiser_ids: z.array(z.string()).optional(),
+  exclude_advertiser_ids: z.array(z.string()).optional(),
+  industry_cluster_ids: z.array(z.string()).optional(),
+  business_model_cluster_ids: z.array(z.string()).optional(),
+  // Proven HOOK seeds (from the `/api/ad-library/seed-catalog` rollup) — narrows
+  // a find-similar search to ads on a chosen winning hook pattern, no cluster
+  // lookup. Forwarded verbatim to ad-dna's `hard_filters.hook_archetype_seeds`;
+  // must live in this schema or the strict boundary parse would drop it.
+  hook_archetype_seeds: z.array(z.string()).optional(),
+  // A static's container (comparison_table, before_after_split, …), the values
+  // `/api/ad-library/seed-catalog` ranks as formats: the best proven example of
+  // a container whatever category it sells.
+  static_format_patterns: z.array(z.string()).optional(),
+  // Who the ad was made for, as the library judged it from the creative: pick
+  // references whose audience matches ours (a cold brief, cold references).
+  audience_temperature: z.array(z.string()).optional(),
+  funnel_stage: z.array(z.string()).optional(),
+  advertiser_size: z.array(z.string()).optional(),
+  // `false` drops the ads known to work only on viewers who already know the
+  // brand (an ad not judged yet is kept); `true` keeps only those.
+  presumes_brand_knowledge: z.boolean().optional(),
+  first_seen_after: z.string().optional(),
+  first_seen_before: z.string().optional(),
+  // Where the ad is in its life (any of these stages), read by ad-dna from its
+  // dates at search time; and `true` for only the version a brand kept after
+  // testing it against others (`false` drops those).
+  lifecycle_stage: z.array(z.string()).optional(),
+  survived_test: z.boolean().optional(),
+  // `true` keeps only ads a creative can be built on (pictures and videos a
+  // brand designed): drops Google search text, Shopping and app ads. A format
+  // list that names `text` lifts it.
+  design_reference: z.boolean().optional(),
+  // `true` keeps only Meta partnership ads (run by the brand with a creator or
+  // another brand); `false` drops them.
+  partnership: z.boolean().optional()
+});
+var firstSeenBoundSchema = z.union([z.iso.date(), z.iso.datetime({ offset: true })], {
+  error: "first_seen_after/first_seen_before must be an ISO date (2026-01-01) or datetime (2026-01-01T00:00:00Z)"
+}).transform((value) => new Date(value.length === 10 ? `${value}T00:00:00Z` : value).toISOString());
+var adFormatSchema = z.enum(["video", "static", "carousel", "text"]);
+var winnerCategorySchema = z.enum([
+  "winner",
+  "grand_slam_winner",
+  "scaled_winner",
+  "low_profile_winner",
+  "rising",
+  "evergreen",
+  "low_traction_dud",
+  "thrash_iteration",
+  "thrash_family",
+  "false_winner",
+  "untested",
+  "dud"
+]);
+var awarenessStageSchema = z.enum([
+  "unaware",
+  "problem_aware",
+  "solution_aware",
+  "product_aware",
+  "most_aware"
+]);
+var audienceTemperatureSchema = z.enum(["0_cold", "1_warm_engaged", "2_hot_visited", "3_customer"]);
+var funnelStageSchema = z.enum(["TOF", "MOF", "BOF"]);
+var advertiserSizeSchema = z.enum(["solo", "smb", "mid", "enterprise"]);
+var staticFormatPatternSchema = z.enum([
+  "clean_product",
+  "lifestyle_photo",
+  "headline_card",
+  "infographic",
+  "chat_screenshot",
+  "tweet_screenshot",
+  "review_screenshot",
+  "before_after_split",
+  "comparison_table",
+  "list_card",
+  "meme_template",
+  "native_post_lookalike",
+  "stock_photo_overlay",
+  "founder_portrait",
+  "testimonial_quote",
+  "packshot_minimalist",
+  "four_panel_lifestyle_grid",
+  "two_panel_split",
+  "notes_app_screenshot",
+  "founder_letter_textonly",
+  "us_vs_them_grid",
+  "benefit_callout_grid",
+  "create_your_own_adventure_meme",
+  "quad_split",
+  "stories_style_casual_static"
+]);
+var validatedHardFiltersSchema = winnersHardFiltersSchema.extend({
+  platform: z.array(adLibraryPlatformSchema).optional(),
+  format: z.array(adFormatSchema).optional(),
+  winner_category: z.array(winnerCategorySchema).optional(),
+  awareness_stage: z.array(awarenessStageSchema).optional(),
+  static_format_patterns: z.array(staticFormatPatternSchema).optional(),
+  audience_temperature: z.array(audienceTemperatureSchema).optional(),
+  funnel_stage: z.array(funnelStageSchema).optional(),
+  advertiser_size: z.array(advertiserSizeSchema).optional(),
+  first_seen_after: firstSeenBoundSchema.optional(),
+  first_seen_before: firstSeenBoundSchema.optional(),
+  lifecycle_stage: z.array(adLifecycleStageSchema).optional()
+});
+var winnersSortSchema = z.enum(["winner", "longest_running", "newest"]);
+var winnersSearchFields = z.object({
+  free_text_query: z.string().max(500).optional(),
+  ref_ad_id: z.string().optional(),
+  limit: z.number().int().min(1).max(100).optional(),
+  // Pagination offset for infinite scroll. The browse view (no query) scrolls
+  // the whole library; a text/similar search scrolls its bounded ranked pool.
+  offset: z.number().int().min(0).optional(),
+  // Per-advertiser cap: past it a brand's ads are dropped. `0` = no cap (the
+  // library browse view sends it so a facet-filtered slice shows every winner
+  // and matches the facet-rail count); omit it to spread the brands instead,
+  // three each at the top and none dropped.
+  max_per_advertiser: z.number().int().min(0).max(50).optional(),
+  // ad-dna reads one advertiser in `advertiser_ids` as browsing that brand, and
+  // keeps its measured failures. `false` keeps it a reference search: what
+  // Baker sends when it narrowed to the company's followed brands itself.
+  brand_browse: z.boolean().optional(),
+  min_relevance: z.number().min(0).max(1).optional(),
+  // One page picked for variety (different brands, containers and hooks)
+  // instead of rank order: a reference set for N concepts. Ignores offset.
+  diverse: z.boolean().optional(),
+  // The order of a browse (no query): by winner score (default), by how long
+  // the ad has run, or by when it was first seen. A query ranks by relevance
+  // blended with winner score, so `sort` only means something without one.
+  sort: winnersSortSchema.optional(),
+  hard_filters: winnersHardFiltersSchema.optional(),
+  // `score_breakdown` surfaces the "why it ranked" panel; facets drive the
+  // filter rail. thumbnails/full_dna_url are opt-in extras.
+  include: z.array(z.enum(["score_breakdown", "facets", "full_dna_url", "thumbnails"])).optional()
+});
+var hasSearchInput = (b) => b.free_text_query !== void 0 || b.ref_ad_id !== void 0 || b.hard_filters !== void 0;
+var SEARCH_INPUT_MESSAGE = "Provide free_text_query, ref_ad_id, or hard_filters";
+var winnerSearchScopeSchema = z.enum(["all", "followed", "followed-first"]);
+var scopedWinnersSearchRequestSchema = winnersSearchFields.extend({
+  scope: winnerSearchScopeSchema.default("followed-first"),
+  hard_filters: validatedHardFiltersSchema.optional()
+}).refine(hasSearchInput, { message: SEARCH_INPUT_MESSAGE }).refine((b) => b.scope !== "followed-first" || !b.offset, {
+  message: "offset is not supported with scope followed-first; raise limit instead"
+});
+var winningAdDnaSchema = z.object({
+  creative_concept: z.string().nullable(),
+  angle: z.string().nullable(),
+  awareness_stage: z.string().nullable(),
+  // How many claims the ad's market has already heard (s1 first to say it … s5 tired of claims).
+  // Optional while an older ad-dna does not send it.
+  sophistication_stage: z.string().nullable().optional(),
+  audience_temperature: z.string().nullable(),
+  // Who else the ad was made for, and whether its copy only works on viewers who
+  // already know the brand (null: not judged yet). Optional while an older
+  // ad-dna does not send them.
+  funnel_stage: z.string().nullable().optional(),
+  advertiser_size: z.string().nullable().optional(),
+  presumes_brand_knowledge: z.boolean().nullable().optional(),
+  brand_knowledge_reason: z.string().nullable().optional(),
+  target_persona: z.string().nullable(),
+  hook_archetype: z.string().nullable(),
+  // The proven hook pattern (`winning-ads hooks` seed) the free-text
+  // `hook_archetype` matches: the value two ads can share. Optional while an
+  // older ad-dna does not send it.
+  hook_seed: z.string().nullable().optional(),
+  creator_type: z.string().nullable(),
+  industry: z.string().nullable(),
+  business_model: z.string().nullable(),
+  // What the viewer sees, the static's container (comparison_table, …) and why
+  // it works: pick a reference on its move, not on its angle label.
+  visual: z.string().nullable(),
+  container: z.string().nullable(),
+  mechanism: z.string().nullable()
+});
+var winningAdScoreBreakdownSchema = z.object({
+  relevance: z.number().nullable(),
+  judge_reason: z.string().nullable(),
+  winner_score: z.number().nullable(),
+  final_score: z.number().nullable()
+});
+var STRONG_PROOF_SCORE = 0.4;
+var SOME_PROOF_SCORE = 0.2;
+function proofStrength(score) {
+  if (score === null || score === void 0) return null;
+  if (score >= STRONG_PROOF_SCORE) return "strong";
+  return score >= SOME_PROOF_SCORE ? "some" : "little";
+}
+var winningAdSchema = z.object({
+  ad_id: z.string().nullable(),
+  advertiser_id: z.string().nullable(),
+  advertiser: z.string().nullable(),
+  platform: z.string().nullable(),
+  format: z.string().nullable(),
+  media_url: z.string().nullable(),
+  media_kind: z.string().nullable(),
+  thumbnail_url: z.string().nullable(),
+  // Query match ∈ [0,1]; null on pure winner browse (no query).
+  relevance: z.number().nullable(),
+  // How proven in-market (global creative strength).
+  winner_score: z.number().nullable(),
+  winner_category: z.string().nullable(),
+  // The score ad-dna ranked the result by (relevance blended with winner
+  // score, or the winner score on a browse). Search results only.
+  final_score: z.number().nullable().optional(),
+  days_active: z.number().nullable(),
+  reach: z.number().nullable(),
+  // Null when the brand hasn't been checked recently enough to say.
+  active: z.boolean().nullable(),
+  // When the brand's ads were last checked: the date `active` was observed.
+  active_checked_at: z.string().nullable(),
+  // Creative family grouping (search dedups launches into one card).
+  creative_id: z.string().nullable(),
+  family_id: z.string().nullable(),
+  member_count: z.number().nullable(),
+  sibling_ad_ids: z.array(z.string()),
+  // Where the ad is in its life, and whether it is the version its brand kept
+  // after testing: what competitors kept is a stronger reference than what
+  // merely runs. Search results only; absent on an older ad-dna.
+  stage: adLifecycleStageSchema.nullable().optional(),
+  survived_test: z.boolean().nullable().optional(),
+  // A Meta partnership ad, run by the brand with a creator or another brand,
+  // and who with (null when Meta does not say). Null for every other ad;
+  // absent on an older ad-dna.
+  partnership: z.object({ partner_name: z.string().nullable() }).nullable().optional(),
+  dna: winningAdDnaSchema,
+  score_breakdown: winningAdScoreBreakdownSchema.nullable()
+});
+var facetCountSchema = z.object({ value: z.string(), label: z.string().optional(), count: z.number() });
+var winnersFacetsSchema = z.object({
+  industry: z.array(facetCountSchema),
+  creator_type: z.array(facetCountSchema),
+  winner_category: z.array(facetCountSchema),
+  format: z.array(facetCountSchema),
+  business_model: z.array(facetCountSchema)
+});
+var winnersSearchResponseSchema = z.object({
+  results: z.array(winningAdSchema),
+  facets: winnersFacetsSchema.nullable(),
+  pool_size: z.number().nullable(),
+  // Bucketed confidence of the top match; null on pure browse.
+  match_confidence: z.enum(["high", "medium", "low"]).nullable(),
+  below_floor_count: z.number().nullable(),
+  query_id: z.string().nullable(),
+  // Pagination window for infinite scroll. `offset` echoes the request; `total`
+  // is how many winners this query+filters can scroll through; `has_more` is
+  // true when more pages exist. Null on an older ad-dna that predates paging —
+  // the dashboard then falls back to a single non-paged page.
+  offset: z.number().nullable(),
+  total: z.number().nullable(),
+  has_more: z.boolean().nullable(),
+  // Ads the corpus holds for each requested `country`; null when the search did
+  // not filter by country. Tells "no winners matched" apart from "unsupported"
+  // (an unknown code is refused outright).
+  country_coverage: z.array(z.object({ code: z.string(), ads: z.number() })).nullable()
+});
+var winnerSourceSchema = z.enum(["followed", "library"]);
+var referenceUsesSchema = z.object({
+  companies: z.number(),
+  ours: z.boolean(),
+  approved: z.number(),
+  rejected: z.number()
+});
+var scopedWinningAdSchema = winningAdSchema.extend({
+  source: winnerSourceSchema,
+  baker_uses: referenceUsesSchema.optional()
+});
+var scopedWinnersSearchResponseSchema = winnersSearchResponseSchema.extend({
+  results: z.array(scopedWinningAdSchema),
+  scope: winnerSearchScopeSchema,
+  // How many brands the company follows; 0 means `followed` answers empty and
+  // `followed-first` is the whole library.
+  following_count: z.number()
+});
+var advertiserPlatformSchema = z.object({
+  platform: z.string(),
+  external_id: z.string().nullable(),
+  region: z.string().nullable(),
+  // The account's own name, e.g. one Facebook page per market; null until its first scan.
+  name: z.string().nullable()
+});
+var advertiserScanSchema = z.object({
+  state: z.enum(["waiting", "running", "failed"]),
+  ads_found: z.number(),
+  since: z.string()
+});
+var corpusAdvertiserSchema = z.object({
+  advertiser_id: z.string(),
+  label: z.string().nullable(),
+  scraped_name: z.string().nullable(),
+  image_url: z.string().nullable(),
+  platforms: z.array(advertiserPlatformSchema),
+  platform_count: z.number().nullable(),
+  family_count: z.number().nullable(),
+  active_ad_count: z.number().nullable(),
+  total_ad_count: z.number().nullable(),
+  total_reach: z.number().nullable(),
+  last_synced_at: z.string().nullable(),
+  // Only the detail read carries it; older ad-dna builds send none.
+  scan: advertiserScanSchema.nullable().optional()
+});
+var advertiserSearchRequestSchema = z.object({
+  q: z.string().optional(),
+  platform: adLibraryPlatformSchema.optional(),
+  limit: z.number().int().min(1).max(100).optional(),
+  offset: z.number().int().min(0).optional()
+});
+var advertiserSearchResponseSchema = z.object({
+  advertisers: z.array(corpusAdvertiserSchema),
+  total: z.number().nullable()
+});
+var advertiserConvergenceSchema = z.object({
+  convergence_state: z.string().nullable(),
+  dimension_summary: z.unknown().nullable(),
+  iteration_velocity_30d: z.number().nullable(),
+  last_refresh_completed_at: z.string().nullable()
+});
+var profileFormatSchema = z.enum(["image", "video", "carousel", "text"]);
+var profileAdRefSchema = z.object({
+  ad_id: z.string(),
+  platform: z.string(),
+  format: profileFormatSchema,
+  headline: z.string().nullable(),
+  media_url: z.string().nullable(),
+  media_kind: z.enum(["image", "video"]).nullable(),
+  is_active: z.boolean()
+});
+var formatMixSchema = z.record(profileFormatSchema, z.number());
+var spendFigureSchema = z.object({ min: z.number(), low: z.number(), high: z.number() });
+var advertiserSpendSchema = spendFigureSchema.extend({
+  currency: z.literal("USD"),
+  method: z.string(),
+  /** First day any priced ad was seen: the lifetime figure runs from here to now. Absent on older responses. */
+  since: z.string().nullable().optional(),
+  last_30_days: spendFigureSchema,
+  /**
+   * Every platform the brand runs on. `ads` counts all its ads there; a
+   * platform that publishes no delivery is listed with zeros and every ad
+   * `unpriced_ads`. Older ad-dna lists priced platforms only, without the last 30 days.
+   */
+  by_platform: z.array(
+    spendFigureSchema.extend({
+      platform: z.string(),
+      ads: z.number(),
+      measured_ads: z.number(),
+      last_30_days: spendFigureSchema.optional(),
+      unpriced_ads: z.number().optional()
+    })
+  ),
+  measured_ads: z.number(),
+  extrapolated_ads: z.number(),
+  unpriced_ads: z.number()
+});
+var creativeTestSchema = z.object({
+  family_id: z.string(),
+  concept: z.string().nullable(),
+  launched_at: z.string(),
+  versions: z.number(),
+  still_running: z.number(),
+  cut_early: z.number(),
+  status: z.enum(["running", "decided"]),
+  // When it was decided: the first version cut, or its third week with none cut. Null while running.
+  decided_at: z.string().nullable().optional(),
+  winner_ad_id: z.string().nullable(),
+  ad_ids: z.array(z.string()),
+  what_differed: z.array(z.object({ dimension: z.string(), winner: z.string(), others: z.array(z.string()) }))
+});
+var ideaStandingSchema = z.enum(["new", "testing", "winner"]);
+var ideaTallyShape = {
+  new_ideas: z.number().optional(),
+  idea_ads: z.object({ new: z.number(), testing: z.number(), winner: z.number() }).optional()
+};
+var advertiserProfileSchema = z.object({
+  spend: advertiserSpendSchema.nullable(),
+  tests: z.array(creativeTestSchema),
+  launch_weeks: z.array(
+    z.object({
+      week_start: z.string(),
+      launched: z.number(),
+      still_running: z.number(),
+      stopped_early: z.number(),
+      ...ideaTallyShape
+    })
+  ),
+  similar: z.array(
+    z.object({
+      advertiser_id: z.string(),
+      label: z.string().nullable(),
+      shared_ads: z.number(),
+      platforms: z.array(z.string())
+    })
+  ),
+  /**
+   * Each day's launches, in ads, in creatives (one creative runs in many ads)
+   * and by idea. The creative counts, `ad_count` and `idea` are optional while
+   * the service that sends them may lag the dashboard; without them `ads` is
+   * one per ad.
+   */
+  launch_calendar: z.array(
+    z.object({
+      date: z.string(),
+      launched: z.number(),
+      still_running: z.number(),
+      creatives: z.number().optional(),
+      creatives_running: z.number().optional(),
+      ...ideaTallyShape,
+      ads: z.array(
+        profileAdRefSchema.extend({ ad_count: z.number().optional(), idea: ideaStandingSchema.nullable().optional() })
+      )
+    })
+  ),
+  recent_launches: z.array(
+    profileAdRefSchema.extend({
+      first_seen_at: z.string().nullable(),
+      stage: adLifecycleStageSchema,
+      idea: ideaStandingSchema.nullable().optional()
+    })
+  ),
+  landing_pages: z.array(
+    z.object({
+      page: z.string(),
+      url: z.string(),
+      ads: z.number(),
+      active_ads: z.number(),
+      last_seen_at: z.string().nullable()
+    })
+  ),
+  audiences: z.object({
+    inferred: z.array(z.object({ audience: z.string(), ads: z.number() })),
+    measured: z.object({
+      ages: z.array(z.object({ age_range: z.string(), male: z.number(), female: z.number(), unknown: z.number() })),
+      countries: z.array(z.object({ country: z.string(), reach: z.number() }))
+    }).nullable(),
+    /**
+     * Google: who the ads were declared to target (by how many ads name each
+     * value) and the countries Google showed them in, by impressions. Google
+     * publishes both only for ads shown in the EU. Null when no ad carries any.
+     */
+    targeting: z.object({
+      ages: z.array(z.object({ value: z.string(), ads: z.number() })),
+      genders: z.array(z.object({ value: z.string(), ads: z.number() })),
+      locations: z.array(z.object({ value: z.string(), excluded: z.boolean(), ads: z.number() })),
+      countries: z.array(z.object({ country: z.string(), impressions: z.number() }))
+    }).nullable().optional()
+  }),
+  freshness: z.object({
+    last_checked_at: z.string().nullable(),
+    next_scan_at: z.string().nullable(),
+    platforms: z.array(z.object({ platform: z.string(), last_checked_at: z.string().nullable() }))
+  }),
+  media_mix: z.object({ total: formatMixSchema, active: formatMixSchema }),
+  platform_split: z.object({ total: z.record(z.string(), z.number()), active: z.record(z.string(), z.number()) }),
+  counts: z.object({
+    total_ads: z.number(),
+    active_ads: z.number(),
+    unique_creatives: z.number(),
+    /** Distinct ideas (ad families; a creative with no family yet is its own). */
+    unique_ideas: z.number().optional(),
+    unique_copies: z.number(),
+    unique_headlines: z.number(),
+    unique_landing_pages: z.number(),
+    new_ads_per_week: z.number()
+  })
+});
+var advertiserLaunchesSchema = z.object({
+  since_days: z.number(),
+  advertisers: z.array(
+    z.object({
+      advertiser_id: z.string(),
+      label: z.string().nullable(),
+      launched: z.number(),
+      still_running: z.number(),
+      launches: z.array(
+        profileAdRefSchema.extend({
+          first_seen_at: z.string().nullable(),
+          stage: adLifecycleStageSchema,
+          idea: ideaStandingSchema.nullable().optional()
+        })
+      ),
+      // The tests the brand decided in the window: the version kept and what
+      // differed. Absent on an older ad-dna.
+      tests_decided: z.array(creativeTestSchema).optional()
+    })
+  )
+});
+var advertiserLandingPageSchema = z.object({
+  /** `https://host/path`, no www., query or fragment: the page's identity and the address it is analysed at. */
+  canonical_url: z.string(),
+  /** The link of the page's most recently seen ad. */
+  url: z.string(),
+  domain: z.string(),
+  path: z.string(),
+  ads: z.number(),
+  active_ads: z.number(),
+  platforms: z.array(z.string()),
+  first_seen_at: z.string().nullable(),
+  last_seen_at: z.string().nullable(),
+  /** The stretches ads pointed here, oldest first; `to` is null on the one still running. Older ad-dna omits it. */
+  windows: z.array(z.object({ from: z.string(), to: z.string().nullable() })).default([]),
+  /**
+   * Only Google search ads name it: the address printed on the ad, whose path
+   * the advertiser types freely, not a page known to exist. Older ad-dna omits it.
+   */
+  address_only: z.boolean().default(false),
+  ads_sample: z.array(profileAdRefSchema)
+});
+var advertiserLandingPagesSchema = z.object({
+  advertiser_id: z.string(),
+  total_pages: z.number(),
+  pages: z.array(advertiserLandingPageSchema)
+});
+var landingAnalysisStatusSchema = z.enum(["not_analysed", "analysing", "ready", "failed"]);
+var landingPitchSchema = z.object({
+  headline: z.string().nullable(),
+  subheadline: z.string().nullable(),
+  value_propositions: z.array(z.string()),
+  offer: z.string().nullable(),
+  pricing: z.array(z.string()),
+  ctas: z.array(z.string()),
+  proof: z.array(z.object({ kind: z.string(), detail: z.string() })),
+  audience: z.string().nullable(),
+  summary: z.string(),
+  /** The page's sections top to bottom (site chrome left out). */
+  sections: z.array(z.object({ type: z.string(), headline: z.string().nullable() }))
+});
+var landingAnalysisSchema = z.object({
+  status: landingAnalysisStatusSchema,
+  title: z.string().nullable(),
+  /** The whole page, top to bottom; read the top for a thumbnail. */
+  screenshot_url: z.string().nullable(),
+  studied_at: z.string().nullable(),
+  /** Why the page could not be read, in product words; null unless `failed`. */
+  error: z.string().nullable(),
+  /** Null until the page's pitch has been read. */
+  pitch: landingPitchSchema.nullable()
+});
+var brandLandingPagesSchema = z.object({
+  advertiser_id: z.string(),
+  total_pages: z.number(),
+  pages: z.array(advertiserLandingPageSchema.extend({ analysis: landingAnalysisSchema }))
+});
+var LANDING_ANALYSE_BATCH = 5;
+var analyseLandingPagesRequestSchema = z.object({
+  urls: z.array(z.string().min(1)).min(1).max(LANDING_ANALYSE_BATCH)
+});
+var analyseLandingPagesResponseSchema = z.object({
+  pages: z.array(z.object({ url: z.string(), status: landingAnalysisStatusSchema, error: z.string().nullable() }))
+});
+var resolvePreviewSchema = z.object({
+  platform: adLibraryPlatformSchema,
+  external_id: z.string(),
+  name: z.string(),
+  image_url: z.string().nullable(),
+  category: z.string().nullable(),
+  industry: z.string().nullable(),
+  website: z.string().nullable(),
+  followers: z.number().nullable()
+});
+var followedStatusSchema = z.enum(["discovering", "ingesting", "ready"]);
+var followedAdvertiserSchema = z.object({
+  // Baker subscription row id (used to unfollow).
+  followed_id: z.string(),
+  advertiser_id: z.string(),
+  label: z.string(),
+  image_url: z.string().nullable(),
+  platforms: z.array(z.object({ platform: adLibraryPlatformSchema, external_id: z.string() })),
+  status: followedStatusSchema,
+  active_ad_count: z.number().nullable(),
+  total_ad_count: z.number().nullable(),
+  family_count: z.number().nullable(),
+  // Progress while status is "discovering" or "ingesting". `adding_ingested`
+  // and `adding_enqueued` are both counts for the CURRENT run, so they read as
+  // a fraction; `total_ad_count` is the brand's whole corpus and is not.
+  adding_discovered: z.number().nullable(),
+  adding_enqueued: z.number().nullable(),
+  adding_ingested: z.number().nullable(),
+  // A discovery job ended in failure, so this brand's ads are under-counted.
+  // Distinguishes "we couldn't finish looking" from "this brand runs no ads".
+  discovery_failed: z.boolean().nullable(),
+  // The current run is still in line upstream: nothing has started on it yet,
+  // which on a backed-up queue can last hours. Optional for older backends.
+  adding_waiting: z.boolean().optional(),
+  // When the run's poll last checked in (ms). See `isScanInFlight`.
+  adding_checked_at: z.number().optional()
+});
+var FOLLOWED_SCAN_QUIET_MS = 15 * 6e4;
+var followingListResponseSchema = z.object({
+  following: z.array(followedAdvertiserSchema)
+});
+var brandDiscoverySchema = z.object({
+  accounts: z.array(resolvePreviewSchema),
+  suggestions: z.array(resolvePreviewSchema)
+});
+var discoverRequestSchema = z.object({ input: z.string().min(1) });
+var BRAND_ACCOUNTS_MAX = 20;
+function brandAccountInput(account) {
+  return ACCOUNT_INPUT[account.platform](account.external_id);
+}
+var ACCOUNT_INPUT = {
+  meta: (id) => `https://www.facebook.com/ads/library/?view_all_page_id=${id}`,
+  linkedin: (id) => `https://www.linkedin.com/company/${id}`,
+  google: (id) => id,
+  tiktok: (id) => id
+};
+function adLibraryUrl(account) {
+  return LIBRARY_URL[account.platform](account.external_id);
+}
+var LIBRARY_URL = {
+  meta: (id) => `https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=ALL&view_all_page_id=${encodeURIComponent(id)}`,
+  linkedin: (id) => `https://www.linkedin.com/ad-library/search?companyIds=${encodeURIComponent(id)}`,
+  // TikTok's library is searched by the advertiser's registered name, which is the id we keep.
+  tiktok: (id) => `https://library.tiktok.com/ads?region=all&adv_name=${encodeURIComponent(id)}&query_type=1`,
+  google: (id) => `https://adstransparency.google.com/advertiser/${encodeURIComponent(id)}?region=anywhere`
+};
+var followRequestSchema = z.object({
+  input: z.string().min(1),
+  // Retired: every platform is tried for every input. Still accepted so older
+  // CLIs keep working; a profile link already says which platform it is.
+  platform: adLibraryPlatformSchema.optional(),
+  // Optional override for the display label; defaults to the resolved name.
+  label: z.string().optional()
+});
+var followResponseSchema = z.object({
+  // "following" = subscribed to an advertiser already in the corpus (no
+  // ingestion). "added" = a new advertiser was enqueued for discovery.
+  // "ambiguous" = the identity mapped to multiple corpus advertisers; the
+  // caller must pick one of `candidates`. "unconfirmed" = only accounts named
+  // like the brand turned up (`suggestions`), so nothing was followed.
+  status: z.enum(["following", "added", "ambiguous", "unconfirmed"]),
+  advertiser: followedAdvertiserSchema.nullable(),
+  preview: resolvePreviewSchema.nullable(),
+  candidates: z.array(corpusAdvertiserSchema).nullable(),
+  // Accounts only named like the brand (another market's page), not tracked
+  // until added with `add-accounts`. Present on a single follow.
+  suggestions: z.array(resolvePreviewSchema).optional()
+});
+var libraryAddRequestSchema = z.object({ input: z.string().min(1) });
+var libraryAddResponseSchema = z.object({
+  // "added" = new to the library, its ads are being collected. "in_library" =
+  // already there (any account it did not have yet is being collected).
+  // "ambiguous" = the accounts belong to several brands already in it, see
+  // `candidates`. "unconfirmed" = only accounts named like the brand turned up
+  // (`suggestions`), so nothing was added.
+  status: z.enum(["added", "in_library", "ambiguous", "unconfirmed"]),
+  advertiser_id: z.string().nullable(),
+  label: z.string().nullable(),
+  // The accounts it was added with: those its website links, or the link given.
+  accounts: z.array(resolvePreviewSchema),
+  // How many accounts are being collected now; 0 when the library had them all.
+  collecting: z.number(),
+  candidates: z.array(corpusAdvertiserSchema).nullable(),
+  suggestions: z.array(resolvePreviewSchema)
+});
+var FOLLOW_BATCH_MAX = 50;
+var followBatchRequestSchema = z.object({
+  // One entry per brand — a domain (best; resolves both Meta + LinkedIn), a
+  // profile / ad-library URL, or a brand name.
+  inputs: z.array(z.string().min(1)).min(1).max(FOLLOW_BATCH_MAX),
+  // Retired: every platform is tried for every input. Still accepted so older
+  // CLIs keep working.
+  platform: adLibraryPlatformSchema.optional()
+});
+var followBatchResultSchema = z.object({
+  // Echoes the input so the caller can line results up with what it sent.
+  input: z.string(),
+  // "following"/"added" mirror the single-follow statuses; "ambiguous" needs a
+  // manual pick; "failed" = we couldn't resolve or add it (see `error`).
+  status: z.enum(["following", "added", "ambiguous", "failed"]),
+  advertiser: followedAdvertiserSchema.nullable(),
+  // Present only when status is "failed" — a plain-language reason.
+  error: z.string().nullable()
+});
+var followBatchResponseSchema = z.object({
+  results: z.array(followBatchResultSchema),
+  // Rollup counts across the batch for a one-glance summary.
+  followed_count: z.number(),
+  added_count: z.number(),
+  ambiguous_count: z.number(),
+  failed_count: z.number()
+});
+var addBrandAccountsRequestSchema = z.object({
+  advertiser_id: z.string().min(1),
+  inputs: z.array(z.string().min(1)).min(1).max(BRAND_ACCOUNTS_MAX)
+});
+var addBrandAccountsResponseSchema = z.object({
+  advertiser: followedAdvertiserSchema.nullable(),
+  // Newly tracked; their ads are being collected.
+  added: z.array(resolvePreviewSchema),
+  // Already part of this brand — nothing to do.
+  already_tracked: z.array(resolvePreviewSchema),
+  // Inputs nothing could be found for, each with a plain-language reason.
+  failed: z.array(z.object({ input: z.string(), error: z.string() }))
+});
+var unfollowRequestSchema = z.object({
+  // Accept either the Baker subscription id or the corpus advertiser id.
+  followed_id: z.string().optional(),
+  advertiser_id: z.string().optional()
+});
+var unfollowResponseSchema = z.object({ removed: z.boolean() });
+var platformWinnersSchema = z.object({
+  platform: adLibraryPlatformSchema,
+  winners: z.array(winningAdSchema)
+});
+var advertiserWinnersResponseSchema = z.object({
+  advertiser_id: z.string(),
+  winners: z.array(winningAdSchema),
+  // `per_platform`: each platform's own top winners. Scores are not comparable
+  // across platforms, so the all-platform list can be one platform's ads only.
+  by_platform: z.array(platformWinnersSchema).optional()
+});
+var advertiserAdsRunningSchema = z.enum(["all", "running", "stopped"]);
+var ADVERTISER_ADS_MAX_LIMIT = 100;
+var advertiserAdsRequestSchema = z.object({
+  id: z.string().min(1),
+  platform: adLibraryPlatformSchema.optional(),
+  running: advertiserAdsRunningSchema.default("all"),
+  // Comma list ("text,video"): only those formats; every format when absent.
+  format: z.string().transform(
+    (s) => s.split(",").map((f) => f.trim()).filter(Boolean)
+  ).pipe(z.array(adFormatSchema).min(1)).optional(),
+  limit: z.coerce.number().int().min(1).max(ADVERTISER_ADS_MAX_LIMIT).default(24),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+var advertiserAdsResponseSchema = z.object({
+  advertiser_id: z.string(),
+  ads: z.array(winningAdSchema),
+  // Every ad the filters match; null from an older library, where a short page means the end.
+  total: z.number().nullable()
+});
+var searchHeadlineHookSchema = z.enum([
+  "category",
+  "brand",
+  "free",
+  "price_discount",
+  "outcome",
+  "proof",
+  "new_timely",
+  "comparison",
+  "audience",
+  "location",
+  "feature",
+  "call_to_action",
+  "question"
+]);
+var searchCopyRequestSchema = z.object({
+  id: z.string().min(1),
+  limit: z.coerce.number().int().min(1).max(100).default(15)
+});
+var searchCopyPartSchema = z.object({
+  text: z.string(),
+  // "dropped": every ad that carried it has stopped.
+  status: z.enum(["running", "dropped"]),
+  ads: z.number(),
+  running_ads: z.number(),
+  first_seen: z.string().nullable(),
+  last_seen: z.string().nullable(),
+  longest_days: z.number().nullable(),
+  landing_pages: z.array(z.string()),
+  example_ad_id: z.string()
+});
+var searchCopySchema = z.object({
+  // `read`: ads whose parts have been read; the rest were extracted before.
+  totals: z.object({ ads: z.number(), running: z.number(), read: z.number(), with_sitelinks: z.number() }),
+  // Distinct parts of each kind, past the list cut. Optional: an older library does not send it.
+  part_totals: z.object({ headlines: z.number(), descriptions: z.number(), sitelinks: z.number(), callouts: z.number() }).optional(),
+  headlines: z.array(
+    searchCopyPartSchema.extend({ hook: searchHeadlineHookSchema.nullable(), names_rival: z.boolean() })
+  ),
+  descriptions: z.array(searchCopyPartSchema),
+  sitelinks: z.array(searchCopyPartSchema),
+  callouts: z.array(searchCopyPartSchema),
+  hooks: z.array(z.object({ hook: searchHeadlineHookSchema, running: z.number(), dropped: z.number() })),
+  rival_headlines: z.array(z.string())
+});
+var searchCopyResponseSchema = searchCopySchema.extend({ advertiser_id: z.string() });
+var searchCopyPartKindSchema = z.enum(["headlines", "descriptions", "sitelinks", "callouts"]);
+var searchCopyPageRequestSchema = z.object({
+  id: z.string().min(1),
+  part: searchCopyPartKindSchema,
+  offset: z.coerce.number().int().min(0).default(0),
+  limit: z.coerce.number().int().min(1).max(100).default(15)
+});
+var searchCopyPageSchema = z.object({
+  parts: z.array(
+    searchCopyPartSchema.extend({
+      hook: searchHeadlineHookSchema.nullable().optional(),
+      names_rival: z.boolean().optional()
+    })
+  ),
+  total: z.number()
+});
+var searchCopyPageResponseSchema = searchCopyPageSchema.extend({
+  advertiser_id: z.string(),
+  part: searchCopyPartKindSchema,
+  offset: z.number()
+});
+var feedRequestSchema = z.object({
+  // Optional subset of your followed advertiser ids to narrow to ("trim down
+  // per advertiser"). Ids you don't follow are ignored and echoed back in
+  // `unknown_requested`. Omit to browse winners across every brand you follow.
+  advertiser_ids: z.array(z.string()).optional(),
+  platform: adLibraryPlatformSchema.optional(),
+  winner_category: z.array(z.string()).optional(),
+  format: z.array(z.string()).optional(),
+  // The feed shows designed pictures and videos by default; `true` adds Google
+  // search text, Shopping and app ads.
+  all_kinds: z.boolean().optional(),
+  // Winners kept per advertiser so no single brand floods the feed. `0` = no
+  // cap. Default applied by the route.
+  per_advertiser: z.number().int().min(0).max(50).optional(),
+  // Total winners returned across all followed advertisers.
+  limit: z.number().int().min(1).max(200).optional()
+});
+var feedResponseSchema = z.object({
+  // The feed only ever reads followed brands, so every winner is `followed`:
+  // the same `source` a scoped search carries, so the surfaces agree.
+  winners: z.array(winningAdSchema.extend({ source: winnerSourceSchema })),
+  // How many brands the company follows (regardless of the trim).
+  following_count: z.number(),
+  // The advertiser ids actually queried (follows ∩ requested subset).
+  advertiser_ids: z.array(z.string()),
+  // Requested ids that aren't followed — a hint the caller mistyped or hasn't
+  // followed them yet.
+  unknown_requested: z.array(z.string())
+});
+var seedCatalogFieldSchema = z.enum(["hook_archetype", "mechanism_type", "static_format_pattern"]);
+var seedCatalogRequestSchema = z.object({
+  field: seedCatalogFieldSchema,
+  platform: z.string().optional(),
+  awareness_stage: z.string().optional(),
+  industry: z.string().optional(),
+  limit: z.number().int().min(1).max(100).optional()
+});
+var patternSeedSchema = z.object({
+  key: z.string(),
+  count: z.number(),
+  sum_winner_score: z.number(),
+  mean_winner_score: z.number(),
+  winner_share: z.number(),
+  // How the seed did inside the brands that used it, the order of the catalog:
+  // the mean, over brands, of how much more often their creatives with the seed
+  // ran 60 days than their others (0 until five brands have a verdict), and
+  // how many brands it won and lost inside.
+  lift: z.number(),
+  brands_for: z.number(),
+  brands_against: z.number(),
+  // Per-segment counts (platform/awareness_stage/industry → value → n); present
+  // only on `--full`, so the response can stay lean by default.
+  breakdown_by: z.record(z.string(), z.unknown()).nullable()
+});
+var seedCatalogSegmentSchema = z.object({
+  platform: z.string().nullable(),
+  awareness_stage: z.string().nullable(),
+  industry: z.string().nullable()
+});
+var seedCatalogResponseSchema = z.object({
+  field: z.string(),
+  segment: seedCatalogSegmentSchema.nullable(),
+  patterns: z.array(patternSeedSchema)
+});
+var adContentRequestSchema = z.object({
+  ad_id: z.string().min(1),
+  platform: adLibraryPlatformSchema.optional()
+});
+var referenceReadRequestSchema = z.object({
+  ad_id: z.string().min(1),
+  platform: adLibraryPlatformSchema.default("meta")
+});
+var referenceReadResponseSchema = z.object({
+  blueprint: z.record(z.string(), z.unknown()),
+  elements: z.array(z.unknown()),
+  credits_charged: z.number(),
+  reused: z.boolean()
+});
+var adContentOverlaySchema = z.object({
+  text: z.string(),
+  appears_at_s: z.number().nullable(),
+  position: z.string().nullable(),
+  role: z.string().nullable(),
+  card: z.number().nullable()
+});
+var adContentSpeechSchema = z.object({
+  speech_pct_of_runtime: z.number().nullable(),
+  speaker_count: z.number().nullable(),
+  voiceover_vs_sync: z.string().nullable(),
+  is_direct_address: z.boolean().nullable(),
+  speech_emotion_dominant: z.string().nullable()
+});
+var adContentPacingSchema = z.object({
+  scene_count: z.number().nullable(),
+  avg_shot_length_s: z.number().nullable(),
+  pacing_shape: z.string().nullable(),
+  hook_ends_at_s: z.number().nullable(),
+  cta_first_shown_at_s: z.number().nullable(),
+  product_first_appears_at_s: z.number().nullable()
+});
+var adContentMusicSchema = z.object({
+  track_title: z.string().nullable(),
+  track_artist: z.string().nullable()
+});
+var adContentLayoutSchema = z.object({
+  format_pattern: z.string().nullable(),
+  composition: z.string().nullable(),
+  focal_subject: z.string().nullable(),
+  aspect_ratio: z.string().nullable(),
+  background: z.string().nullable(),
+  palette_mood: z.string().nullable(),
+  colors: z.array(z.string()),
+  production: z.string().nullable(),
+  aesthetic: z.array(z.string()),
+  cta_in_image: z.string().nullable(),
+  markers: z.array(z.string()),
+  card_roles: z.array(z.string())
+});
+var adContentMessageSchema = z.object({
+  awareness_stage: z.string().nullable(),
+  sophistication: z.string().nullable(),
+  mechanism: z.string().nullable(),
+  pain_points: z.array(z.string()),
+  desires: z.array(z.string()),
+  value_props: z.array(z.string()),
+  objections_handled: z.array(z.string()),
+  proof: z.array(z.string()),
+  risk_reversal: z.array(z.string())
+});
+var adContentOfferSchema = z.object({
+  offer_type: z.string().nullable(),
+  pricing_model: z.string().nullable(),
+  entry_price: z.string().nullable(),
+  no_credit_card: z.boolean().nullable(),
+  guarantee: z.array(z.string()),
+  guarantee_days: z.number().nullable(),
+  urgency: z.string().nullable(),
+  bonus: z.string().nullable()
+});
+var adLifecycleSchema = z.object({
+  stage: adLifecycleStageSchema,
+  survived_test: z.boolean(),
+  test: creativeTestSchema.nullable()
+});
+var GOOGLE_AD_TYPES = ["search", "display", "shopping", "youtube", "app"];
+var googleAdTypeSchema = z.enum(GOOGLE_AD_TYPES);
+var landingElsewhereSchema = z.enum([
+  "meta_native",
+  "linkedin_native",
+  "messaging",
+  "social_profile",
+  "app_store",
+  "file"
+]);
+var adContentSearchAdSchema = z.object({
+  // A hook this version does not know reads as none rather than losing the ad's parts.
+  headlines: z.array(z.object({ text: z.string(), hook: searchHeadlineHookSchema.nullable().catch(null) })),
+  descriptions: z.array(z.string()),
+  sitelinks: z.array(z.string()),
+  callouts: z.array(z.string()),
+  rating: z.object({ stars: z.number().nullable(), reviews: z.number().nullable() }).nullable()
+});
+var adContentSchema = z.object({
+  ad_id: z.string().nullable(),
+  advertiser: z.string().nullable(),
+  advertiser_id: z.string().nullable(),
+  platform: z.string().nullable(),
+  format: z.string().nullable(),
+  media_kind: z.string().nullable(),
+  media_url: z.string().nullable(),
+  winner_score: z.number().nullable(),
+  winner_category: z.string().nullable(),
+  summary: z.string().nullable(),
+  angle: z.string().nullable(),
+  hook_archetype: z.string().nullable(),
+  // Spoken words (video only; null when the ad has no speech track).
+  transcript: z.string().nullable(),
+  has_speech: z.boolean().nullable(),
+  speech: adContentSpeechSchema,
+  // On-screen text / captions.
+  has_captions: z.boolean().nullable(),
+  caption_style: z.string().nullable(),
+  on_screen_text: z.array(adContentOverlaySchema),
+  // Copy the viewer reads outside the media.
+  primary_text: z.string().nullable(),
+  headline: z.string().nullable(),
+  // Where the ad sends people: the page a short or tracking link leads to once
+  // followed. Null when the link opens no page of the brand's; optional while
+  // an older backend does not send it.
+  landing_url: z.string().nullable().optional(),
+  // Why the link opens no page: an Instant Form or Experience inside Meta, a
+  // chat, an app store, a social profile, a LinkedIn page, a file.
+  landing_elsewhere: landingElsewhereSchema.nullable().optional(),
+  cta: z.string().nullable(),
+  // Structure + soundtrack.
+  pacing: adContentPacingSchema,
+  music: adContentMusicSchema,
+  layout: adContentLayoutSchema,
+  message: adContentMessageSchema,
+  offer: adContentOfferSchema,
+  // Where the ad is in its life, whether it is the version its brand kept
+  // after testing, and the test when it is one version of a tested concept.
+  // Absent on an older ad-dna.
+  lifecycle: adLifecycleSchema.nullable().optional(),
+  // Which kind of Google ad it is; null off Google or when the library does
+  // not say. Absent on an older ad-dna.
+  google_ad_type: googleAdTypeSchema.nullable().optional(),
+  // A Google search ad's headlines, descriptions, sitelinks, callouts and
+  // rating; null on every other ad. A search ad has no layout, colours or
+  // on-screen text of its own (Google draws it), so those stay empty on it.
+  // Absent on an older backend.
+  search_ad: adContentSearchAdSchema.nullable().optional()
+});
+var adContentResponseSchema = z.object({ ad: adContentSchema });
+var adDnaColorSchema = z.object({
+  hex: z.string(),
+  share: z.number().nullable()
+});
+var adDnaSceneSchema = z.object({
+  start_s: z.number(),
+  end_s: z.number(),
+  role: z.string().nullable(),
+  visual: z.string(),
+  speech: z.string().nullable(),
+  on_screen_text: z.string().nullable(),
+  sound: z.string().nullable()
+});
+var adDnaMomentSchema = z.object({
+  kind: z.enum(["hook_ends", "product", "price", "cta", "logo"]),
+  at_s: z.number()
+});
+var adDnaStorySchema = z.object({
+  duration_s: z.number().nullable(),
+  summary: z.string().nullable(),
+  hook: z.string().nullable(),
+  scenes: z.array(adDnaSceneSchema),
+  moments: z.array(adDnaMomentSchema)
+});
+var adDnaCardSchema = z.object({
+  index: z.number(),
+  role: z.string().nullable(),
+  layout: z.string().nullable(),
+  colors: z.array(adDnaColorSchema),
+  open_loop: z.string().nullable(),
+  transition: z.string().nullable()
+});
+var adDnaAgeReachSchema = z.object({
+  age_range: z.string(),
+  female: z.number(),
+  male: z.number(),
+  unknown: z.number()
+});
+var adDnaReachSchema = z.object({
+  total: z.number().nullable(),
+  eu_total: z.number().nullable(),
+  ages: z.object({ min: z.number(), max: z.number() }).nullable(),
+  gender: z.string().nullable(),
+  locations: z.array(z.string()),
+  excluded_locations: z.array(z.string()),
+  channels: z.array(z.string()),
+  by_age: z.array(adDnaAgeReachSchema)
+});
+var adDnaTraitSchema = z.object({
+  key: z.string(),
+  value: z.union([z.string(), z.number(), z.boolean(), z.array(z.string())])
+});
+var adDnaTraitGroupKeySchema = z.enum([
+  "audience",
+  "business",
+  "message",
+  "copy",
+  "look",
+  "cast",
+  "pacing",
+  "sound",
+  "on_screen_text",
+  "branding",
+  "subject",
+  "cta_visual",
+  "markers",
+  "carousel",
+  "offer",
+  "delivery"
+]);
+var adDnaTraitGroupSchema = z.object({
+  key: adDnaTraitGroupKeySchema,
+  traits: z.array(adDnaTraitSchema)
+});
+var adDnaDetailSchema = z.object({
+  palette: z.array(adDnaColorSchema),
+  background_hex: z.string().nullable(),
+  button_hex: z.string().nullable(),
+  story: adDnaStorySchema.nullable(),
+  cards: z.array(adDnaCardSchema),
+  reach: adDnaReachSchema.nullable(),
+  groups: z.array(adDnaTraitGroupSchema),
+  extracted_at: z.string().nullable()
+});
+var adCardMediaSchema = z.object({
+  index: z.number(),
+  url: z.string(),
+  kind: z.enum(["image", "video"]).nullable()
+});
+var adDetailSchema = z.object({
+  content: adContentSchema,
+  dna: adDnaDetailSchema,
+  card_media: z.array(adCardMediaSchema)
+});
+
+// src/schemas.ts
+var registry = /* @__PURE__ */ new Map();
+var tree;
+function registerCommandTree(root) {
+  tree = root;
+}
+function commandTree() {
+  return tree;
+}
+var PAYLOAD_SHAPE = Symbol("payloadShape");
+function payloadArg(arg, shape) {
+  return { ...arg, [PAYLOAD_SHAPE]: shape };
+}
+function payloadShapeOf(arg) {
+  if (typeof arg !== "object" || arg === null) return void 0;
+  const shape = arg[PAYLOAD_SHAPE];
+  return typeof shape === "function" ? shape() : void 0;
+}
+function registerSchema(schema) {
+  registry.set(schema.command, schema);
+}
+function listSchemas() {
+  return [...registry.keys()];
+}
+function spellingKey(name) {
+  return name.toLowerCase().replaceAll("-", "");
+}
+function resolveSchemaName(words, names) {
+  const joined = words.join(".");
+  if (names.includes(joined)) {
+    return joined;
+  }
+  const matches = names.filter((name) => spellingKey(name) === spellingKey(joined));
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function findSchema(words) {
+  const name = resolveSchemaName(words, listSchemas());
+  return name === void 0 ? void 0 : registry.get(name);
+}
+
+// src/unknown-flags.ts
+import { stripVTControlCharacters } from "util";
+import { parseArgs } from "citty";
+import { quote } from "shell-quote";
+var ALWAYS_ACCEPTED = /* @__PURE__ */ new Set(["help", "h", "version"]);
+function subCommandsOf(command) {
+  const sub = command.subCommands;
+  return sub && typeof sub === "object" ? sub : null;
+}
+function argsOf(command) {
+  const args = command.args;
+  return args && typeof args === "object" ? args : null;
+}
+function resolveCommand(root, argv) {
+  let command = root;
+  for (const token of argv) {
+    if (token === "--" || token.startsWith("-")) {
+      break;
+    }
+    const subCommands = subCommandsOf(command);
+    if (!subCommands) {
+      break;
+    }
+    const next = subCommands[token];
+    if (next === void 0) {
+      break;
+    }
+    if (typeof next !== "object") {
+      return { command, resolved: false };
+    }
+    command = next;
+  }
+  return { command, resolved: true };
+}
+function typeOf(def) {
+  return def && typeof def === "object" ? def.type : void 0;
+}
+function acceptedNames(command) {
+  const args = argsOf(command);
+  if (!args) {
+    return null;
+  }
+  const names = new Set(ALWAYS_ACCEPTED);
+  for (const [name, def] of Object.entries(args)) {
+    if (typeOf(def) === "positional") {
+      continue;
+    }
+    for (const spelling of [name, kebab(name), camel(name)]) {
+      names.add(spelling);
+      if (typeOf(def) === "boolean") {
+        names.add(`no-${spelling}`);
+      }
+    }
+  }
+  return names;
+}
+function kebab(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function camel(name) {
+  return name.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function findUnknownFlags(root, argv) {
+  const { command, resolved } = resolveCommand(root, argv);
+  if (!resolved) {
+    return [];
+  }
+  const accepted = acceptedNames(command);
+  if (!accepted) {
+    return [];
+  }
+  const unknown = [];
+  for (const token of argv) {
+    if (token === "--") {
+      break;
+    }
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    const name = token.slice(2).split("=")[0] ?? "";
+    if (name.length > 0 && !accepted.has(name) && !unknown.includes(token)) {
+      unknown.push(token);
+    }
+  }
+  return unknown;
+}
+var SYNONYMS = {
+  from: ["start-date", "start", "since"],
+  since: ["start-date", "start"],
+  start: ["start-date", "since"],
+  to: ["end-date", "end", "until"],
+  until: ["end-date", "end"],
+  end: ["end-date", "until"],
+  path: ["landing"],
+  url: ["landing"]
+};
+function closestFlag(unknown, command) {
+  const accepted = acceptedNames(command);
+  if (!accepted) {
+    return null;
+  }
+  const name = unknown.replace(/^--/, "").split("=")[0] ?? "";
+  const synonym = SYNONYMS[name]?.find((candidate) => accepted.has(candidate));
+  if (synonym) {
+    return `--${synonym}`;
+  }
+  const scored = [...accepted].filter((candidate) => !ALWAYS_ACCEPTED.has(candidate)).map((candidate) => ({
+    candidate,
+    prefix: sharedPrefix(name, candidate),
+    distance: editDistance(name, candidate)
+  })).filter(({ prefix, distance }) => prefix >= 4 || distance <= typoBudget(name)).sort((a, b) => b.prefix - a.prefix || a.distance - b.distance);
+  return scored[0] ? `--${scored[0].candidate}` : null;
+}
+function typoBudget(name) {
+  return Math.max(1, Math.floor(name.length / 3));
+}
+function sharedPrefix(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) {
+    i++;
+  }
+  return i;
+}
+function editDistance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const substitution = (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1);
+      current.push(Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, substitution));
+    }
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+function commandFor(root, argv) {
+  const { command, resolved } = resolveCommand(root, argv);
+  return resolved ? command : null;
+}
+function suggestFlag(unknown, command) {
+  const flag = closestFlag(unknown, command);
+  if (!flag) {
+    return null;
+  }
+  const args = argsOf(command) ?? {};
+  const name = flag.slice(2);
+  const def = args[name] ?? args[camel(name)];
+  const described = def && typeof def === "object" ? def.description : void 0;
+  const description = typeof described === "string" ? described.split(/(?<!\b(?:e\.g|i\.e|vs))\.\s/)[0]?.trim().replace(/\.$/, "") : "";
+  return description ? { flag, description } : { flag };
+}
+function suggestionText(suggestion) {
+  if (!suggestion) {
+    return "";
+  }
+  return suggestion.description ? `Did you mean ${suggestion.flag}? It is described as: ${suggestion.description}. ` : `Did you mean ${suggestion.flag}? `;
+}
+var OUTPUT_EXPLANATION = "This command has no --output option: `--output json` and `--output md` are accepted by every command that prints the JSON envelope, and files only where `baker schema` lists `output`. Drop the option and read the default output. ";
+function unknownFlagEnvelope(unknown, commandPath, suggestion, hasSchema) {
+  const list = unknown.join(", ");
+  return {
+    ok: false,
+    error: {
+      code: "UNKNOWN_ARGUMENT",
+      message: `${list} ${unknown.length > 1 ? "are not options" : "is not an option"} of \`baker ${commandPath}\`.`,
+      fix: {
+        action: hasSchema ? "check_schema" : "check_help",
+        explanation: (unknown.some((flag) => flag === "--output" || flag.startsWith("--output=")) ? OUTPUT_EXPLANATION : "") + suggestionText(suggestion) + `Run \`${hasSchema ? `baker schema ${commandPath}` : `baker ${commandPath} --help`}\` to see every option this command takes. Do not re-run the same call: until this version an unrecognised option was accepted and ignored, so a command that looked like it had filtered or narrowed the result was in fact answering the unfiltered question.`
+      },
+      retryable: false
+    }
+  };
+}
+function commandPathOf(root, argv) {
+  const path = [];
+  let command = root;
+  for (const token of argv) {
+    if (token === "--" || token.startsWith("-")) {
+      break;
+    }
+    const subCommands = subCommandsOf(command);
+    const next = subCommands?.[token];
+    if (next === void 0 || typeof next !== "object") {
+      break;
+    }
+    path.push(token);
+    command = next;
+  }
+  return path.join(" ");
+}
+function refuseUnknownFlags(root, argv, typed = argv) {
+  const refusal = unknownFlagRefusal(root, argv, typed);
+  if (!refusal) {
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(refusal, null, 2)}
+`);
+  process.exit(1);
+}
+function unknownFlagRefusal(root, argv, typed = argv) {
+  const unknown = findUnknownFlags(root, argv);
+  if (unknown.length === 0) {
+    return null;
+  }
+  const command = commandFor(root, argv);
+  const first = unknown[0];
+  const suggestion = command && first ? suggestFlag(first, command) : null;
+  const path = commandPathOf(root, argv);
+  const envelope = unknownFlagEnvelope(unknown, path, suggestion, findSchema(path.split(" ")) !== void 0);
+  if (!command || !first) {
+    return envelope;
+  }
+  const positional = positionalNamed(first, command);
+  if (!positional) {
+    return envelope;
+  }
+  const correctedCommand = unknown.length === 1 ? positionalCall(command, path, argv, typed, root, first, positional) : null;
+  return {
+    ...envelope,
+    error: {
+      ...envelope.error,
+      fix: {
+        action: "use_positional",
+        explanation: `\`${first.split("=")[0]}\` is not an option: \`${positional.name}\` is a positional argument of \`baker ${path}\`, so write its value bare, with no flag${positional.index === 0 ? ", right after the command" : ""}.`,
+        ...correctedCommand ? { correctedCommand } : {},
+        usage: usageLine(path, usageArgsOf(command)),
+        validOptions: optionsOf(command)
+      }
+    }
+  };
+}
+function usageArgsOf(command) {
+  return Object.entries(argsOf(command) ?? {}).map(([name, def]) => {
+    const {
+      required,
+      default: fallback,
+      description
+    } = def ?? {};
+    const positional = typeOf(def) === "positional";
+    return {
+      name,
+      positional,
+      required: positional ? required !== false && fallback === void 0 : required === true,
+      boolean: typeOf(def) === "boolean",
+      description: typeof description === "string" ? description : ""
+    };
+  });
+}
+function optionsOf(command) {
+  return usageArgsOf(command).filter((arg) => !arg.positional).map((arg) => `--${kebab(arg.name)}`);
+}
+function usageLine(path, args) {
+  const positionals = args.filter((arg) => arg.positional).map((arg) => arg.required ? `<${arg.name}>` : `[${arg.name}]`);
+  const options = args.filter((arg) => !arg.positional);
+  const required = options.filter((arg) => arg.required).map((arg) => arg.boolean ? `--${kebab(arg.name)}` : `--${kebab(arg.name)} <${kebab(arg.name)}>`);
+  const more = options.length > required.length ? ["[options]"] : [];
+  return ["baker", path, ...positionals, ...required, ...more].filter((part) => part !== "").join(" ");
+}
+function positionalsOf(command) {
+  return Object.entries(argsOf(command) ?? {}).filter(([, def]) => typeOf(def) === "positional").map(([name]) => name);
+}
+function positionalNamed(flag, command) {
+  const key = spellingKey(flag.replace(/^--/, "").split("=")[0] ?? "");
+  const positionals = positionalsOf(command);
+  const index = positionals.findIndex((name2) => spellingKey(name2) === key);
+  const name = positionals[index];
+  return name === void 0 ? null : { name, index };
+}
+function positionalCall(command, path, argv, typed, root, flag, positional) {
+  const judged = withoutOption(argv, path, flag);
+  const written = withoutOption(typed, path, flag);
+  if (positional.index !== 0 || !judged || !written || commandPathOf(root, typed) !== path) {
+    return null;
+  }
+  try {
+    if (parseArgs(judged.others, positionalsOptional(command))._.length > 0) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  const words = written.value.startsWith("-") ? [...written.others, "--", written.value] : [written.value, ...written.others];
+  return `baker ${path} ${words.map(shellWord).join(" ")}`;
+}
+function shellWord(word) {
+  if (word.includes("'") && word.includes("!")) {
+    return `'${word.replaceAll("'", `'\\''`)}'`;
+  }
+  return quote([word]);
+}
+function positionalsOptional(command) {
+  return Object.fromEntries(
+    Object.entries(argsOf(command) ?? {}).map(([name, def]) => [
+      name,
+      typeOf(def) === "positional" ? { ...def, required: false } : def
+    ])
+  );
+}
+function withoutOption(argv, path, flag) {
+  const rest = argv.slice(path === "" ? 0 : path.split(" ").length);
+  const at = rest.indexOf(flag);
+  const inline = flag.includes("=");
+  const value = inline ? flag.slice(flag.indexOf("=") + 1) : rest[at + 1];
+  if (at < 0 || value === void 0 || value === "" || !inline && value.startsWith("-")) {
+    return null;
+  }
+  return { value, others: [...rest.slice(0, at), ...rest.slice(at + (inline ? 1 : 2))] };
+}
+function lookItUp(commandPath) {
+  const hasSchema = commandPath !== "" && findSchema(commandPath.split(" ")) !== void 0;
+  return hasSchema ? { action: "check_schema", how: `Run \`baker schema ${commandPath}\` to see every argument it takes.` } : {
+    action: "check_help",
+    how: `Run \`baker${commandPath ? ` ${commandPath}` : ""} --help\` to see every argument it takes.`
+  };
+}
+function invalidArgsEnvelope(message, commandPath, explanation = "") {
+  const { action, how } = lookItUp(commandPath);
+  return {
+    ok: false,
+    error: {
+      code: "INVALID_ARGS",
+      message,
+      fix: { action, explanation: `${explanation}${how}` },
+      retryable: false
+    }
+  };
+}
+function subCommandNames(command) {
+  return Object.keys(subCommandsOf(command) ?? {});
+}
+var READ_ONE_VERBS = /* @__PURE__ */ new Set(["view", "show"]);
+function closestSubCommands(name, parent) {
+  const names = subCommandNames(parent);
+  const scored = names.map((candidate) => ({ candidate, distance: editDistance(name, candidate) })).filter(({ distance }) => distance <= Math.max(2, typoBudget(name))).sort((a, b) => a.distance - b.distance);
+  if (scored[0]) {
+    return [scored[0].candidate];
+  }
+  if (READ_ONE_VERBS.has(name) && names.includes("get")) {
+    return ["get"];
+  }
+  const stem = name.split("-")[0] ?? name;
+  return names.map((candidate) => ({ candidate, distance: editDistance(stem, candidate.split("-")[0] ?? candidate) })).filter(({ candidate, distance }) => candidate.includes("-") && distance <= typoBudget(stem)).sort((a, b) => a.distance - b.distance).slice(0, 3).map(({ candidate }) => candidate);
+}
+var CITTY_REFUSALS = /* @__PURE__ */ new Set(["EARG", "E_UNKNOWN_COMMAND", "E_NO_COMMAND"]);
+function cittyRefusalCode(error) {
+  if (!(error instanceof Error) || error.name !== "CLIError") {
+    return null;
+  }
+  const code = error.code;
+  return typeof code === "string" && CITTY_REFUSALS.has(code) ? code : null;
+}
+function firstUnknownWord(argv, pathLength, command) {
+  const rest = argv.slice(pathLength);
+  try {
+    return parseArgs(rest, argsOf(command) ?? {})._[0];
+  } catch {
+    return rest.find((token) => !token.startsWith("-"));
+  }
+}
+function parseRefusalEnvelope(error, root, argv) {
+  const code = cittyRefusalCode(error);
+  if (code === null || !(error instanceof Error)) {
+    return null;
+  }
+  const path = commandPathOf(root, argv);
+  const command = commandFor(root, argv) ?? root;
+  const where = `\`baker${path ? ` ${path}` : ""}\``;
+  if (code === "E_UNKNOWN_COMMAND") {
+    const word = firstUnknownWord(argv, path === "" ? 0 : path.split(" ").length, command) ?? "";
+    return unknownSubCommandEnvelope(word, path, command);
+  }
+  if (code === "E_NO_COMMAND") {
+    return invalidArgsEnvelope(`${where} needs a command: one of ${subCommandNames(command).join(", ")}.`, path);
+  }
+  return invalidArgsEnvelope(missingArgMessage(error.message, where), path);
+}
+function unknownSubCommandEnvelope(word, path, command) {
+  const closest = closestSubCommands(word, command).map((name) => `\`baker${path ? ` ${path}` : ""} ${name}\``);
+  return invalidArgsEnvelope(
+    `\`${word}\` is not a command of \`baker${path ? ` ${path}` : ""}\`. Its commands: ${subCommandNames(command).join(", ")}.`,
+    path,
+    closest.length > 0 ? `Did you mean ${closest.join(" or ")}? ` : ""
+  );
+}
+function unknownSubCommandRefusal(root, argv) {
+  const delimiter = argv.indexOf("--");
+  const rest = (delimiter === -1 ? argv : argv.slice(0, delimiter)).filter((arg) => arg !== "--help" && arg !== "-h");
+  const command = commandFor(root, rest);
+  const subCommands = command === null ? void 0 : subCommandsOf(command);
+  if (command === null || !subCommands) {
+    return null;
+  }
+  const path = commandPathOf(root, rest);
+  const word = firstUnknownWord(rest, path === "" ? 0 : path.split(" ").length, command);
+  return word === void 0 || word in subCommands ? null : unknownSubCommandEnvelope(word, path, command);
+}
+function missingArgMessage(cittyMessage, where) {
+  const plain = stripVTControlCharacters(cittyMessage);
+  const positional = /^Missing required positional argument: (\S+)/.exec(plain)?.[1];
+  const missing = positional ? `<${positional.toLowerCase()}>` : /^Missing required argument: (--\S+)/.exec(plain)?.[1];
+  return missing ? `${missing} is required by ${where}.` : `${plain.replace(/\.$/, "")} (${where}).`;
+}
+var READS_ITS_OWN_POSITIONALS = [
+  "schema",
+  "actions status",
+  "credentials",
+  "images download",
+  ...["get", "ingest", "use", "delete"].map((name) => `images ${name}`),
+  "videos get",
+  "videos ingest",
+  "testimonials get",
+  "landing critique",
+  // `research cite <url> "<span>" "<span>"…`: every word after the URL is a span.
+  "research cite",
+  "ads performance families choices",
+  "ads google",
+  "ads meta",
+  "ads linkedin",
+  "ads x",
+  "ads chatgpt",
+  ...[
+    "key-event",
+    "custom-dimension",
+    "custom-metric",
+    "custom-event",
+    "data-retention",
+    "audience",
+    "property",
+    "ads-link",
+    "enhanced-measurement",
+    "draft"
+  ].map((name) => `ga4 ${name}`),
+  ...["tag", "trigger", "variable", "folder", "builtin", "draft"].map((name) => `tag-manager ${name}`),
+  ...["product", "promotions", "change", "draft", "changes", "undo"].map((name) => `shopify ${name}`)
+];
+function readsItsOwnPositionals(commandPath) {
+  return READS_ITS_OWN_POSITIONALS.some((entry) => commandPath === entry || commandPath.startsWith(`${entry} `));
+}
+function findStrayPositionals(root, argv) {
+  const { command, resolved } = resolveCommand(root, argv);
+  const args = argsOf(command) ?? {};
+  const path = commandPathOf(root, argv);
+  if (!resolved || subCommandsOf(command) || argv.includes("--") || readsItsOwnPositionals(path)) {
+    return [];
+  }
+  const rest = argv.slice(path === "" ? 0 : path.split(" ").length);
+  let positionals;
+  try {
+    positionals = parseArgs(rest, args)._;
+  } catch {
+    return [];
+  }
+  const declared = Object.values(args).filter((def) => typeOf(def) === "positional").length;
+  return positionals.slice(declared);
+}
+var BOOLEAN_WORD = /^(true|false)$/i;
+function refuseStrayPositionals(root, argv) {
+  const stray = findStrayPositionals(root, argv);
+  if (stray.length === 0) {
+    return;
+  }
+  const path = commandPathOf(root, argv);
+  const declared = Object.entries(argsOf(commandFor(root, argv) ?? root) ?? {}).filter(([, def]) => typeOf(def) === "positional").map(([name]) => `<${name}>`);
+  const takes = declared.length === 0 ? "takes no positional argument" : `takes only ${declared.join(" ")}`;
+  const booleanWord = stray.some((word) => BOOLEAN_WORD.test(word)) ? "A boolean flag written with a space is set to TRUE and the word is dropped: attach it instead (--flag=false), or use --no-flag. " : "";
+  process.stdout.write(
+    `${JSON.stringify(
+      invalidArgsEnvelope(
+        `${stray.map((word) => `\`${word}\``).join(", ")}: \`baker ${path}\` ${takes}, so ${stray.length > 1 ? "these were" : "this was"} not read.`,
+        path,
+        `${booleanWord}Pass each value with the flag it belongs to (\`--name value\`), or drop it. `
+      ),
+      null,
+      2
+    )}
+`
+  );
+  process.exit(1);
+}
+
+// src/printed-envelope.ts
+function parsePrintedEnvelope(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return null;
+  }
+  return typeof parsed.ok === "boolean" ? parsed : null;
+}
+function reprint(text, envelope) {
+  const indent = text.trimStart().startsWith("{\n") ? 2 : void 0;
+  return `${JSON.stringify(envelope, null, indent)}${text.endsWith("\n") ? "\n" : ""}`;
+}
+function withHint(envelope, hint) {
+  return { ...envelope, hints: [...Array.isArray(envelope.hints) ? envelope.hints : [], hint] };
+}
+function rewriteWrites(stream, rewrite) {
+  let applied = false;
+  const write2 = stream.write.bind(stream);
+  stream.write = (chunk, ...rest) => {
+    const rewritten = typeof chunk === "string" ? rewrite(chunk) : null;
+    if (rewritten === null) {
+      return write2(chunk, ...rest);
+    }
+    applied = true;
+    return write2(rewritten, ...rest);
+  };
+  return { sawEnvelope: () => applied };
+}
+
+// src/output-flag.ts
+var FLAG = "--output";
+var ENVELOPE = "json";
+var PRINTS_NO_ENVELOPE = /* @__PURE__ */ new Set(["analytics sending-events", "canvas sync-definition"]);
+var PRINTS_PROGRESS_BEFORE_ENVELOPE = /* @__PURE__ */ new Set(["canvas run", "canvas rerun"]);
+var OUTPUT_IS_NOT_A_FORMAT = /* @__PURE__ */ new Set(["creatives publish"]);
+function printsDataEnvelope(commandPath) {
+  return !PRINTS_NO_ENVELOPE.has(commandPath) && !PRINTS_PROGRESS_BEFORE_ENVELOPE.has(commandPath);
+}
+function declaredArg(command, name) {
+  const args = command.args;
+  if (!args || typeof args !== "object" || !(name in args)) {
+    return null;
+  }
+  const def = args[name];
+  return def && typeof def === "object" ? def : {};
+}
+var FORMAT_NAMES = /\b(json|csv|jsonl|md|files)\b/g;
+function ownOutput(command, commandPath) {
+  const def = declaredArg(command, "output");
+  if (def === null) {
+    return { kind: "absent" };
+  }
+  const description = typeof def.description === "string" ? def.description : "";
+  if (OUTPUT_IS_NOT_A_FORMAT.has(commandPath) || /\bpath\b/i.test(description)) {
+    return { kind: "not-a-format" };
+  }
+  const fallback = typeof def.default === "string" ? def.default : "json";
+  const named = [...description.matchAll(FORMAT_NAMES)].map((match) => match[1] ?? "");
+  return { kind: "formats", formats: /* @__PURE__ */ new Set([...named, fallback]), default: fallback };
+}
+function withOutput(argv, format) {
+  const end = argv.indexOf("--");
+  const at = end === -1 ? argv.length : end;
+  return [...argv.slice(0, at), FLAG, format, ...argv.slice(at)];
+}
+function outputRequests(argv) {
+  const end = argv.indexOf("--");
+  const limit = end === -1 ? argv.length : end;
+  const found = [];
+  for (let index = 0; index < limit; index++) {
+    const token = argv[index] ?? "";
+    if (token.startsWith(`${FLAG}=`)) {
+      found.push({ indices: [index], value: token.slice(FLAG.length + 1) });
+    } else if (token === FLAG && index + 1 < limit) {
+      found.push({ indices: [index, index + 1], value: argv[index + 1] ?? "" });
+      index++;
+    }
+  }
+  return found;
+}
+function envelopeRequests(argv) {
+  const end = argv.indexOf("--");
+  const limit = end === -1 ? argv.length : end;
+  const found = [];
+  for (let index = 0; index < limit; index++) {
+    const token = argv[index];
+    if (token === `${FLAG}=${ENVELOPE}`) {
+      found.push({ index, length: 1 });
+    } else if (token === FLAG && argv[index + 1] === ENVELOPE && index + 1 < limit) {
+      found.push({ index, length: 2 });
+      index++;
+    }
+  }
+  return found;
+}
+function outputFlagForCommand(root, argv) {
+  const requests = envelopeRequests(argv);
+  if (requests.length === 0) {
+    return argv;
+  }
+  const command = commandFor(root, argv);
+  if (!command) {
+    return argv;
+  }
+  const path = commandPathOf(root, argv);
+  const ownFormat = declaredArg(command, "output") !== null && !OUTPUT_IS_NOT_A_FORMAT.has(path);
+  if (ownFormat || PRINTS_NO_ENVELOPE.has(path)) {
+    return argv;
+  }
+  const jsonSwitch = declaredArg(command, "json")?.type === "boolean";
+  const dropped = new Set(requests.flatMap(({ index, length }) => length === 2 ? [index, index + 1] : [index]));
+  const first = requests[0]?.index;
+  return argv.flatMap((token, index) => {
+    if (!dropped.has(index)) {
+      return [token];
+    }
+    return jsonSwitch && index === first ? ["--json"] : [];
+  });
+}
+function printsEnvelopeAlone(root, argv) {
+  if (argv.some((arg) => arg === "--help" || arg === "-h")) return false;
+  return PRINTS_PROGRESS_BEFORE_ENVELOPE.has(commandPathOf(root, argv));
+}
+function envelopeAloneOnStdout(stdout, stderr) {
+  const toStdout = stdout.write.bind(stdout);
+  const toStderr = stderr.write.bind(stderr);
+  const route = (chunk, ...rest) => typeof chunk === "string" && parsePrintedEnvelope(chunk) !== null ? toStdout(chunk, ...rest) : toStderr(chunk, ...rest);
+  stdout.write = route;
+  stderr.write = route;
+}
+
+// src/field-mask.ts
+var FLAG2 = "--fields";
+function parseFields(value) {
+  return value.split(",").map((field) => field.trim()).filter((field) => field.length > 0);
+}
+function takeFieldsFlag(root, argv) {
+  const end = argv.indexOf("--");
+  const limit = end === -1 ? argv.length : end;
+  const taken = /* @__PURE__ */ new Set();
+  const fields = [];
+  for (let index = 0; index < limit; index++) {
+    const token = argv[index] ?? "";
+    if (token.startsWith(`${FLAG2}=`)) {
+      taken.add(index);
+      fields.push(...parseFields(token.slice(FLAG2.length + 1)));
+    } else if (token === FLAG2) {
+      const value = argv[index + 1];
+      if (value === void 0 || index + 1 >= limit || value.startsWith("-")) {
+        return { argv, fields: null };
+      }
+      taken.add(index).add(index + 1);
+      fields.push(...parseFields(value));
+      index++;
+    }
+  }
+  if (taken.size === 0 || fields.length === 0) {
+    return { argv, fields: null };
+  }
+  const command = commandFor(root, argv);
+  if (!command || declaredArg(command, "fields") || !printsDataEnvelope(commandPathOf(root, argv))) {
+    return { argv, fields: null };
+  }
+  return { argv: argv.filter((_, index) => !taken.has(index)), fields };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pick(record, fields) {
+  return Object.fromEntries(fields.filter((field) => field in record).map((field) => [field, record[field]]));
+}
+function soleList(data) {
+  const lists = Object.entries(data).filter(
+    (entry) => Array.isArray(entry[1]) && entry[1].length > 0 && entry[1].every((item) => isRecord(item))
+  );
+  return lists.length === 1 ? lists[0] ?? null : null;
+}
+function wrappedList(data, fields) {
+  const rowFields = fields.filter((field) => !(field in data));
+  const list = soleList(data);
+  if (list === null || !list[1].some((row) => rowFields.some((field) => field in row))) {
+    return null;
+  }
+  return list[0];
+}
+function recordsOf(data, fields) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (!isRecord(data)) {
+    return [];
+  }
+  const list = wrappedList(data, fields);
+  return list === null ? [data] : data[list];
+}
+function maskData(data, fields) {
+  const maskWith = (keep) => (item) => isRecord(item) ? pick(item, keep) : item;
+  if (Array.isArray(data)) {
+    return data.map(maskWith(fields));
+  }
+  if (!isRecord(data)) {
+    return data;
+  }
+  const list = wrappedList(data, fields);
+  if (list === null) {
+    return pick(data, fields);
+  }
+  const wrapperFields = fields.filter((field) => field in data);
+  const rows = recordsOf(data, fields).map(maskWith(fields.filter((field) => !(field in data))));
+  return { ...wrapperFields.length > 0 ? pick(data, wrapperFields) : data, [list]: rows };
+}
+function unmatchedHint(data, fields) {
+  const records = recordsOf(data, fields).filter(isRecord);
+  if (records.length === 0) {
+    return null;
+  }
+  const keys = isRecord(data) ? [data, ...soleList(data)?.[1] ?? []] : records;
+  const carried = new Set(keys.flatMap((record) => Object.keys(record)));
+  const unmatched = fields.filter((field) => !carried.has(field));
+  if (unmatched.length === 0) {
+    return null;
+  }
+  return `--fields matched nothing for: ${unmatched.join(", ")}. The keys data carries are: ${[...carried].join(", ")}.`;
+}
+var NO_DATA_HINT = "--fields was not applied: this result carries no data to narrow, so it is printed whole. Drop --fields on this command.";
+function maskPrintedEnvelope(text, fields) {
+  const parsed = parsePrintedEnvelope(text);
+  if (parsed === null) {
+    return null;
+  }
+  if (parsed.ok !== true || "dryRun" in parsed) {
+    return text;
+  }
+  return reprint(text, maskEnvelope(parsed, fields));
+}
+function maskEnvelope(envelope, fields) {
+  if (!("data" in envelope)) {
+    return withHint(envelope, NO_DATA_HINT);
+  }
+  const masked = { ...envelope, data: maskData(envelope.data, fields) };
+  const miss = unmatchedHint(envelope.data, fields);
+  return miss ? withHint(masked, miss) : masked;
+}
+function maskWrites(stream, fields) {
+  return rewriteWrites(stream, (text) => maskPrintedEnvelope(text, fields));
+}
+function installFieldMask(fields, commandPath) {
+  const mask = maskWrites(process.stdout, fields);
+  process.on("exit", () => {
+    if (!mask.sawEnvelope()) {
+      process.stderr.write(
+        `--fields was not applied: \`baker ${commandPath}\` printed no JSON envelope to narrow. Add --output json to get the envelope, or drop --fields.
+`
+      );
+    }
+  });
+}
+
+// src/output.ts
+var ASPECT_RATIO_MAP = {
+  "1:1": 1,
+  "16:9": 16 / 9,
+  "9:16": 9 / 16,
+  "2:3": 2 / 3,
+  "3:4": 3 / 4,
+  "1:2": 1 / 2,
+  "2:1": 2,
+  "4:5": 4 / 5,
+  "3:2": 3 / 2,
+  "4:3": 4 / 3
+};
+var ASPECT_RATIO_TOLERANCE = 0.08;
+function formatAspectRatio(ratio) {
+  if (ratio === void 0 || ratio === null) {
+    return null;
+  }
+  for (const [label, value] of Object.entries(ASPECT_RATIO_MAP)) {
+    if (Math.abs(ratio - value) / value < ASPECT_RATIO_TOLERANCE) {
+      return label;
+    }
+  }
+  return null;
+}
+function groupSummary(record) {
+  const key = record.groupKey;
+  if (typeof key !== "string" || !key) {
+    return null;
+  }
+  const index = typeof record.groupIndex === "number" ? record.groupIndex : null;
+  const size = typeof record.groupSize === "number" ? record.groupSize : null;
+  return {
+    key,
+    kind: typeof record.groupKind === "string" ? record.groupKind : null,
+    position: index === null ? null : size === null ? `${index + 1}` : `${index + 1} of ${size}`,
+    title: typeof record.groupTitle === "string" ? record.groupTitle : null,
+    url: typeof record.groupUrl === "string" ? record.groupUrl : null
+  };
+}
+function peopleLines(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    const person = asRecord(entry);
+    const role = typeof person.role === "string" ? person.role : "";
+    if (!role) {
+      return [];
+    }
+    const identity = typeof person.identity === "string" && person.identity ? ` \u2014 ${person.identity}` : "";
+    const appearance = typeof person.appearance === "string" && person.appearance ? ` (${person.appearance})` : "";
+    const speaking = person.speaking === true ? " [speaking]" : "";
+    return [`${role}${identity}${appearance}${speaking}`];
+  });
+}
+function compactImage(image) {
+  const analysis = asRecord(image.analysis);
+  return {
+    _id: String(image._id ?? ""),
+    name: String(image.name ?? ""),
+    imageUrl: String(image.imageUrl ?? ""),
+    description: String(image.description ?? ""),
+    tags: Array.isArray(image.tags) ? image.tags : [],
+    // Two numbers that are not about choosing the image but about placing it.
+    // A remote <BakerImage> with no width/height makes Astro DOWNLOAD the file
+    // at build time just to measure it — one request per image per build, on a
+    // build that is otherwise offline, and a single dropped connection there
+    // fails a client's whole verify. They are cheap enough to always carry, and
+    // burying them behind --full meant the agent placing the image never had
+    // them.
+    width: typeof image.width === "number" ? image.width : null,
+    height: typeof image.height === "number" ? image.height : null,
+    // The facts that decide a pick, so choosing does not need a second call:
+    // whose brand it is, who is in it, and what text is burned in.
+    subject: typeof analysis.subject === "string" ? analysis.subject : null,
+    brandOwnership: typeof analysis.brandOwnership === "string" ? analysis.brandOwnership : null,
+    people: peopleLines(analysis.people),
+    textInImage: Array.isArray(analysis.textInImage) ? analysis.textInImage : [],
+    group: groupSummary(image)
+  };
+}
+function fullImage(image) {
+  const compact = compactImage(image);
+  return {
+    ...compact,
+    aspectRatio: formatAspectRatio(image.aspectRatio),
+    dominantColor: image.dominantColor ?? null,
+    imagePalette: Array.isArray(image.imagePalette) ? image.imagePalette : [],
+    source: String(image.source ?? ""),
+    externalUrl: image.externalUrl ?? null,
+    originalFilename: image.originalFilename ?? null,
+    descriptionContext: image.descriptionContext ?? null,
+    style: typeof asRecord(image.analysis).style === "string" ? asRecord(image.analysis).style : null,
+    composition: typeof asRecord(image.analysis).composition === "string" ? asRecord(image.analysis).composition : null,
+    usageNotes: typeof asRecord(image.analysis).usageNotes === "string" ? asRecord(image.analysis).usageNotes : null,
+    createdAt: image.createdAt ?? null
+  };
+}
+function imageNormalizer(record, full) {
+  if (full) {
+    return fullImage(record);
+  }
+  return compactImage(record);
+}
+function sellingFacts(analysis) {
+  return {
+    format: typeof analysis.format === "string" ? analysis.format : null,
+    tone: typeof analysis.tone === "string" ? analysis.tone : null,
+    productClaims: Array.isArray(analysis.productClaims) ? analysis.productClaims : null
+  };
+}
+function embedFacts(video) {
+  return {
+    duration: typeof video.duration === "number" ? video.duration : null,
+    muxPlaybackId: String(video.muxPlaybackId ?? ""),
+    aspectRatio: typeof video.aspectRatio === "number" ? video.aspectRatio : null
+  };
+}
+function compactVideo(video) {
+  const analysis = asRecord(video.analysis);
+  const sceneCount = typeof video.sceneCount === "number" ? video.sceneCount : Array.isArray(video.scenes) ? video.scenes.length : 0;
+  return {
+    _id: String(video._id ?? ""),
+    name: String(video.name ?? ""),
+    thumbnailUrl: String(video.thumbnailUrl ?? ""),
+    description: String(video.description ?? ""),
+    tags: Array.isArray(video.tags) ? video.tags : [],
+    status: String(video.status ?? ""),
+    ...embedFacts(video),
+    // What decides whether this clip is usable, without a second call: who is
+    // on camera and in what role, what language they speak, how it opens, and
+    // how many beats there are to cut from.
+    subject: typeof analysis.subject === "string" ? analysis.subject : null,
+    brandOwnership: typeof analysis.brandOwnership === "string" ? analysis.brandOwnership : null,
+    people: peopleLines(analysis.people),
+    spokenLanguages: Array.isArray(analysis.spokenLanguages) ? analysis.spokenLanguages : [],
+    hook: typeof analysis.hook === "string" ? analysis.hook : null,
+    ...sellingFacts(analysis),
+    sceneCount,
+    group: groupSummary(video)
+  };
+}
+function sceneDecoration(scene) {
+  const shot = typeof scene.shot === "string" && scene.shot ? ` [${scene.shot}]` : "";
+  const change = typeof scene.visualChange === "string" && scene.visualChange ? ` <${scene.visualChange}>` : "";
+  const overlayText = Array.isArray(scene.onScreenText) ? scene.onScreenText.filter(Boolean) : [];
+  let overlay = "";
+  if (scene.hasOverlay === true) {
+    overlay = overlayText.length > 0 ? ` \u2014 banner: "${overlayText.join('" / "')}"` : " \u2014 banner";
+  } else if (scene.hasOverlay === false) {
+    overlay = " \u2014 clean frame";
+  }
+  const spoken = typeof scene.spoken === "string" && scene.spoken ? ` \u2014 says: "${scene.spoken}"` : "";
+  return `${shot}${change}${overlay}${spoken}`;
+}
+function sceneLines(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((s) => {
+    const scene = asRecord(s);
+    const title = typeof scene.title === "string" ? scene.title : "";
+    if (!title) {
+      return [];
+    }
+    const start = round2(scene.startSecond);
+    const end = round2(scene.endSecond);
+    const range = start !== null && end !== null ? ` (${start}-${end}s)` : "";
+    return [`${title}${range}${sceneDecoration(scene)}`];
+  });
+}
+function fullVideo(video) {
+  const compact = compactVideo(video);
+  return {
+    ...compact,
+    source: String(video.source ?? ""),
+    // The spoken transcript + AI scene breakdown of the client's own clip — the
+    // "understand what's in this video" payload. Kept out of the compact/search
+    // projection (too large for a list) and surfaced here on --full.
+    transcript: video.transcript ?? null,
+    transcript_segment_count: Array.isArray(video.transcriptSegments) ? video.transcriptSegments.length : 0,
+    scenes: sceneLines(video.scenes),
+    originalFilename: video.originalFilename ?? null,
+    descriptionContext: video.descriptionContext ?? null,
+    shotStyle: typeof asRecord(video.analysis).shotStyle === "string" ? asRecord(video.analysis).shotStyle : null,
+    audioStyle: typeof asRecord(video.analysis).audioStyle === "string" ? asRecord(video.analysis).audioStyle : null,
+    onScreenText: Array.isArray(asRecord(video.analysis).onScreenText) ? asRecord(video.analysis).onScreenText : [],
+    usageNotes: typeof asRecord(video.analysis).usageNotes === "string" ? asRecord(video.analysis).usageNotes : null,
+    createdAt: video.createdAt ?? null
+  };
+}
+function videoNormalizer(record, full) {
+  if (full) {
+    return fullVideo(record);
+  }
+  return compactVideo(record);
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength)}...`;
+}
+function compactTestimonial(record) {
+  return {
+    _id: String(record._id ?? ""),
+    reviewerName: String(record.reviewerName ?? ""),
+    reviewText: truncate(String(record.reviewText ?? ""), 200),
+    rating: record.rating ?? null,
+    sentiment: record.sentiment ?? null,
+    tags: Array.isArray(record.tags) ? record.tags : [],
+    sourceType: String(record.sourceType ?? "")
+  };
+}
+function fullTestimonial(record) {
+  const compact = compactTestimonial(record);
+  return {
+    ...compact,
+    reviewText: String(record.reviewText ?? ""),
+    highlight: record.highlight ?? null,
+    summary: record.summary ?? null,
+    language: record.language ?? null,
+    reviewerImageUrl: record.reviewerImageUrl ?? null,
+    sourceUrl: record.sourceUrl ?? null,
+    reviewDate: record.reviewDate ?? null,
+    createdAt: record.createdAt ?? null,
+    status: String(record.status ?? "")
+  };
+}
+function testimonialNormalizer(record, full) {
+  if (full) {
+    return fullTestimonial(record);
+  }
+  return compactTestimonial(record);
+}
+function round2(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    return null;
+  }
+  return Math.round(value * 100) / 100;
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function bakerUses(value) {
+  const uses = asRecord(value);
+  const companies = typeof uses.companies === "number" ? uses.companies : 0;
+  if (companies === 0) return {};
+  const count = (n) => typeof n === "number" && n > 0 ? n : void 0;
+  const approved = count(uses.approved);
+  const rejected = count(uses.rejected);
+  return {
+    baker_uses: companies,
+    ...uses.ours === true ? { already_adapted: true } : {},
+    ...approved !== void 0 ? { approved } : {},
+    ...rejected !== void 0 ? { rejected } : {}
+  };
+}
+function dnaMove(dna) {
+  const text = (value) => typeof value === "string" && value ? value : void 0;
+  const visual = text(dna.visual);
+  const container = text(dna.container);
+  const mechanism = text(dna.mechanism);
+  return {
+    ...visual ? { visual } : {},
+    ...container ? { container } : {},
+    ...mechanism ? { mechanism } : {}
+  };
+}
+function dnaAudience(dna) {
+  const text = (value) => typeof value === "string" && value ? value : void 0;
+  const audienceTemperature = text(dna.audience_temperature);
+  const funnelStage = text(dna.funnel_stage);
+  const advertiserSize = text(dna.advertiser_size);
+  const presumes = typeof dna.presumes_brand_knowledge === "boolean" ? dna.presumes_brand_knowledge : void 0;
+  const reason = presumes ? text(dna.brand_knowledge_reason) : void 0;
+  return {
+    ...audienceTemperature ? { audience_temperature: audienceTemperature } : {},
+    ...funnelStage ? { funnel_stage: funnelStage } : {},
+    ...advertiserSize ? { advertiser_size: advertiserSize } : {},
+    ...presumes !== void 0 ? { presumes_brand_knowledge: presumes } : {},
+    ...reason ? { brand_knowledge_reason: reason } : {}
+  };
+}
+function partnershipFields(value) {
+  if (value === null || typeof value !== "object") return {};
+  const partner = asRecord(value).partner_name;
+  return { partnership: true, ...typeof partner === "string" && partner ? { partner } : {} };
+}
+function compactWinningAd(record) {
+  const dna = asRecord(record.dna);
+  return {
+    advertiser: String(record.advertiser ?? ""),
+    platform: String(record.platform ?? ""),
+    format: String(record.format ?? ""),
+    relevance: round2(record.relevance),
+    winner_score: round2(record.winner_score),
+    winner_category: typeof record.winner_category === "string" ? record.winner_category : null,
+    proof: proofStrength(typeof record.winner_score === "number" ? record.winner_score : null),
+    days_active: typeof record.days_active === "number" ? record.days_active : null,
+    active: typeof record.active === "boolean" ? record.active : null,
+    summary: String(dna.creative_concept ?? ""),
+    advertiser_id: String(record.advertiser_id ?? ""),
+    ad_id: String(record.ad_id ?? ""),
+    media_url: String(record.media_url ?? ""),
+    ...typeof record.stage === "string" ? { stage: record.stage } : {},
+    ...record.survived_test === true ? { survived_test: true } : {},
+    ...partnershipFields(record.partnership),
+    ...dnaMove(dna),
+    ...dnaAudience(dna),
+    ...bakerUses(record.baker_uses),
+    ...record.source === "followed" || record.source === "library" ? { source: record.source } : {}
+  };
+}
+function fullWinningAd(record) {
+  const compact = compactWinningAd(record);
+  const dna = asRecord(record.dna);
+  return {
+    ...compact,
+    media_kind: record.media_kind ?? null,
+    reach: record.reach ?? null,
+    angle: dna.angle ?? null,
+    awareness_stage: dna.awareness_stage ?? null,
+    target_persona: dna.target_persona ?? null,
+    hook_archetype: dna.hook_archetype ?? null,
+    mechanism: dna.mechanism ?? null,
+    industry: dna.industry ?? null
+  };
+}
+function winningAdNormalizer(record, full) {
+  if (full) {
+    return fullWinningAd(record);
+  }
+  return compactWinningAd(record);
+}
+function inImageLine(item, text, detailed) {
+  const card = typeof item.card === "number" ? `card ${item.card} \xB7 ` : "";
+  const role = typeof item.role === "string" && item.role.length > 0 ? `${item.role}: ` : "";
+  const position = detailed && typeof item.position === "string" && item.position.length > 0 ? ` [${item.position}]` : "";
+  return `${card}${role}${text}${position}`;
+}
+function overlayLines(value, detailed = false, inImage = false) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((o) => {
+    const item = asRecord(o);
+    const text = typeof item.text === "string" ? item.text : "";
+    if (!text) {
+      return [];
+    }
+    if (inImage) {
+      return [inImageLine(item, text, detailed)];
+    }
+    const at = round2(item.appears_at_s);
+    let line = at !== null ? `${text} @${at}s` : text;
+    if (detailed) {
+      const tags = [item.role, item.position].filter((t) => typeof t === "string" && t.length > 0);
+      if (tags.length) {
+        line += ` [${tags.join(", ")}]`;
+      }
+    }
+    return [line];
+  });
+}
+var STOPPED_STAGES = /* @__PURE__ */ new Set(["killed_early", "retired"]);
+function adLifecycleFields(adId, value) {
+  const lifecycle = asRecord(value);
+  if (typeof lifecycle.stage !== "string") return {};
+  const test = asRecord(lifecycle.test);
+  const keptAdId = typeof test.winner_ad_id === "string" ? test.winner_ad_id : null;
+  const thisVersion = keptAdId !== null && keptAdId === adId ? "kept" : STOPPED_STAGES.has(lifecycle.stage) ? "cut" : "running";
+  return {
+    stage: lifecycle.stage,
+    ...lifecycle.survived_test === true ? { survived_test: true } : {},
+    ...typeof test.status === "string" ? {
+      test: {
+        status: test.status,
+        versions: test.versions,
+        this_version: thisVersion,
+        kept_ad_id: keptAdId,
+        what_differed: test.what_differed ?? []
+      }
+    } : {}
+  };
+}
+function landingAndKind(record) {
+  return {
+    ...typeof record.landing_url === "string" ? { landing_url: record.landing_url } : {},
+    // Why the link opens no page: meta_native (an Instant Form or Experience), messaging, app_store…
+    ...typeof record.landing_elsewhere === "string" ? { landing_elsewhere: record.landing_elsewhere } : {},
+    ...typeof record.google_ad_type === "string" ? { google_ad_type: record.google_ad_type } : {}
+  };
+}
+function searchAdParts(raw) {
+  const parsed = adContentSearchAdSchema.safeParse(raw);
+  if (!parsed.success) return {};
+  const { headlines, descriptions, sitelinks, callouts, rating } = parsed.data;
+  return filledOnly({
+    headlines: headlines.map((h) => h.hook ? `${h.text} (${h.hook})` : h.text),
+    descriptions,
+    sitelinks,
+    callouts,
+    rating
+  });
+}
+function compactAdContent(record) {
+  const inImage = record.format === "static" || record.format === "carousel";
+  return {
+    ad_id: record.ad_id ?? null,
+    advertiser: record.advertiser ?? null,
+    format: record.format ?? null,
+    media_kind: record.media_kind ?? null,
+    media_url: record.media_url ?? null,
+    summary: record.summary ?? null,
+    transcript: record.transcript ?? null,
+    on_screen_text: overlayLines(record.on_screen_text, false, inImage),
+    // The container a static reference is built on (comparison_table, before_after_split…).
+    ...inImage ? { format_pattern: asRecord(record.layout).format_pattern ?? null } : {},
+    has_captions: typeof record.has_captions === "boolean" ? record.has_captions : null,
+    primary_text: record.primary_text ?? null,
+    headline: record.headline ?? null,
+    cta: record.cta ?? null,
+    ...landingAndKind(record),
+    ...searchAdParts(record.search_ad),
+    ...adLifecycleFields(record.ad_id, record.lifecycle)
+  };
+}
+function filledOnly(value) {
+  return Object.fromEntries(
+    Object.entries(asRecord(value)).filter(
+      ([, v]) => v !== null && v !== void 0 && !(Array.isArray(v) && v.length === 0)
+    )
+  );
+}
+function fullAdContent(record) {
+  const speech = asRecord(record.speech);
+  const pacing = asRecord(record.pacing);
+  const music = asRecord(record.music);
+  return {
+    ...compactAdContent(record),
+    platform: record.platform ?? null,
+    // Re-derive with role/position tags — the lean compact version dropped them.
+    on_screen_text: overlayLines(
+      record.on_screen_text,
+      true,
+      record.format === "static" || record.format === "carousel"
+    ),
+    winner_score: round2(record.winner_score),
+    winner_category: record.winner_category ?? null,
+    angle: record.angle ?? null,
+    hook_archetype: record.hook_archetype ?? null,
+    caption_style: record.caption_style ?? null,
+    has_speech: typeof record.has_speech === "boolean" ? record.has_speech : null,
+    speech_pct_of_runtime: round2(speech.speech_pct_of_runtime),
+    speaker_count: speech.speaker_count ?? null,
+    voiceover_vs_sync: speech.voiceover_vs_sync ?? null,
+    is_direct_address: typeof speech.is_direct_address === "boolean" ? speech.is_direct_address : null,
+    speech_emotion_dominant: speech.speech_emotion_dominant ?? null,
+    scene_count: pacing.scene_count ?? null,
+    avg_shot_length_s: round2(pacing.avg_shot_length_s),
+    pacing_shape: pacing.pacing_shape ?? null,
+    hook_ends_at_s: round2(pacing.hook_ends_at_s),
+    cta_first_shown_at_s: round2(pacing.cta_first_shown_at_s),
+    product_first_appears_at_s: round2(pacing.product_first_appears_at_s),
+    music_track_title: music.track_title ?? null,
+    music_track_artist: music.track_artist ?? null,
+    // How it is built, how it persuades, and what it offers, flattened like
+    // speech/pacing above so --output md renders them, and only when present.
+    ...filledOnly(record.layout),
+    ...filledOnly(record.message),
+    ...filledOnly(record.offer)
+  };
+}
+function adContentNormalizer(record, full) {
+  return full ? fullAdContent(record) : compactAdContent(record);
+}
+function applyFieldMask(data, fields) {
+  const result = {};
+  for (const field of fields) {
+    if (field in data) {
+      result[field] = data[field];
+    }
+  }
+  return result;
+}
+function write(text) {
+  process.stdout.write(text);
+}
+function writeJson(envelope) {
+  write(`${JSON.stringify(envelope, null, 2)}
+`);
+}
+function cell(value) {
+  if (value === null || value === void 0) return "";
+  return typeof value === "object" ? JSON.stringify(value) : String(value);
+}
+function writeFiles(data, fields) {
+  write(`${fields.join("	")}
+`);
+  for (const item of data) {
+    const values = fields.map((f) => cell(item[f]));
+    write(`${values.join("	")}
+`);
+  }
+}
+function writeMd(data, fields) {
+  write(`| ${fields.join(" | ")} |
+`);
+  write(`| ${fields.map(() => "---").join(" | ")} |
+`);
+  for (const item of data) {
+    const values = fields.map((f) => cell(item[f]));
+    write(`| ${values.join(" | ")} |
+`);
+  }
+}
+function normalizeData(envelope, fields, full, normalizer) {
+  const raw = Array.isArray(envelope.data) ? envelope.data : [envelope.data];
+  const items = raw.map((item) => {
+    const record = item;
+    return normalizer(record, full);
+  });
+  if (fields) {
+    return items.map((item) => applyFieldMask(item, fields));
+  }
+  return items;
+}
+function writeOutput(envelope, format, fields, full, normalizer) {
+  if (!envelope.ok || "dryRun" in envelope) {
+    writeJson(envelope);
+    return;
+  }
+  if (format === "json") {
+    write(`${JSON.stringify(fields ? maskEnvelope(envelope, fields) : envelope, null, 2)}
+`);
+    return;
+  }
+  if (format !== "files" && format !== "md") {
+    process.stderr.write(`Unknown --output "${String(format)}". Valid formats: json, files, md. Using json.
+`);
+    writeJson(envelope);
+    return;
+  }
+  const items = normalizeData(envelope, fields, full ?? false, normalizer ?? imageNormalizer);
+  const displayFields = fields ?? Object.keys(items[0] ?? {});
+  if (format === "files") {
+    writeFiles(items, displayFields);
+  } else {
+    writeMd(items, displayFields);
+  }
+  writeHints(envelope.hints);
+}
+function writeHints(hints) {
+  for (const hint of hints ?? []) {
+    process.stderr.write(`${hint}
+`);
+  }
+}
+
+export {
+  staticFormatPatternSchema,
+  winnersSortSchema,
+  winnerSearchScopeSchema,
+  scopedWinnersSearchRequestSchema,
+  proofStrength,
+  LANDING_ANALYSE_BATCH,
+  BRAND_ACCOUNTS_MAX,
+  brandAccountInput,
+  adLibraryUrl,
+  FOLLOW_BATCH_MAX,
+  advertiserAdsRequestSchema,
+  searchCopyPartKindSchema,
+  referenceReadResponseSchema,
+  parsePrintedEnvelope,
+  reprint,
+  withHint,
+  rewriteWrites,
+  registerCommandTree,
+  commandTree,
+  payloadArg,
+  payloadShapeOf,
+  registerSchema,
+  listSchemas,
+  spellingKey,
+  findSchema,
+  commandFor,
+  commandPathOf,
+  refuseUnknownFlags,
+  usageArgsOf,
+  usageLine,
+  parseRefusalEnvelope,
+  unknownSubCommandRefusal,
+  refuseStrayPositionals,
+  printsDataEnvelope,
+  declaredArg,
+  ownOutput,
+  withOutput,
+  outputRequests,
+  outputFlagForCommand,
+  printsEnvelopeAlone,
+  envelopeAloneOnStdout,
+  takeFieldsFlag,
+  maskEnvelope,
+  installFieldMask,
+  compactImage,
+  fullImage,
+  compactVideo,
+  videoNormalizer,
+  testimonialNormalizer,
+  compactWinningAd,
+  fullWinningAd,
+  winningAdNormalizer,
+  adContentNormalizer,
+  applyFieldMask,
+  writeJson,
+  writeOutput
+};
+//# sourceMappingURL=chunk-NXNOXZGB.js.map