@koda-sl/baker-cli 0.551.0 → 0.552.0

package/dist/chunk-WCIS4FZH.js

@@ -1,2505 +0,0 @@
-// ../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;
-}
-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 asksForEnvelopeAlone(root, argv) {
-  return envelopeRequests(argv).length > 0 && 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 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 ?? ""),
-    // 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,
-    duration: video.duration ?? null,
-    muxPlaybackId: String(video.muxPlaybackId ?? ""),
-    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,
-  registerSchema,
-  listSchemas,
-  spellingKey,
-  findSchema,
-  commandFor,
-  commandPathOf,
-  refuseUnknownFlags,
-  usageArgsOf,
-  usageLine,
-  parseRefusalEnvelope,
-  unknownSubCommandRefusal,
-  refuseStrayPositionals,
-  printsDataEnvelope,
-  declaredArg,
-  ownOutput,
-  withOutput,
-  outputRequests,
-  outputFlagForCommand,
-  asksForEnvelopeAlone,
-  envelopeAloneOnStdout,
-  takeFieldsFlag,
-  maskEnvelope,
-  installFieldMask,
-  compactImage,
-  fullImage,
-  compactVideo,
-  videoNormalizer,
-  testimonialNormalizer,
-  compactWinningAd,
-  fullWinningAd,
-  winningAdNormalizer,
-  adContentNormalizer,
-  applyFieldMask,
-  writeJson,
-  writeOutput
-};
-//# sourceMappingURL=chunk-WCIS4FZH.js.map