@koda-sl/baker-cli 0.383.0 → 0.384.0-dev.557795bef

package/dist/shopify-RQKO5TMR.js

@@ -0,0 +1,3819 @@
+import {
+  landingGraphFiles
+} from "./chunk-Z3ENMCFE.js";
+import {
+  failValidation,
+  loadJsonArg,
+  loadJsonPayloads
+} from "./chunk-PY2NJ6XZ.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-EIGXX6KI.js";
+import {
+  CHAT_READ_ARG
+} from "./chunk-PFBQERWX.js";
+import {
+  failApi
+} from "./chunk-JUY47NZ2.js";
+import "./chunk-O6XZIQXZ.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-I2DNBEV6.js";
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-CUL3VB4L.js";
+import "./chunk-6YYSUISH.js";
+import {
+  optionalChatId,
+  requireChatId,
+  resolveChatId
+} from "./chunk-I4FTS5EE.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-MYTDK3AL.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/shopify/index.ts
+import { defineCommand as defineCommand8 } from "citty";
+
+// src/commands/shopify/buyers.ts
+import { defineCommand } from "citty";
+
+// src/commands/shopify/buyerHints.ts
+var AUDIENCE_PATH = "To reach more people like your buyers on Meta, stage an audience of the store's purchasers (`baker ads meta audiences create --subtype WEBSITE`) and a lookalike of it (`--subtype LOOKALIKE`). Baker cannot upload a list of buyers to an ad platform.";
+var MIN_ORDERS_TO_SCALE = 5;
+function storeFactsHint(currency) {
+  return `These are the store's own orders \u2014 never a demo or sample store: build the answer on them and quote their numbers${currency ? ` in ${currency}` : ""}. If Knowledge describes other products or markets, say the two disagree and ask which is current \u2014 never drop these numbers for it.`;
+}
+var percent = (value) => `${Math.round(value * 100)}%`;
+function buyerHistoryHints(history, basis) {
+  const hints = [];
+  if (history.state === "importing") {
+    hints.push(
+      `Baker is still bringing in this store's past orders (${history.orders} so far): older periods, repeat buyers and cohorts are incomplete \u2014 say so rather than reporting a drop.`
+    );
+  }
+  if (history.state === "failed") {
+    hints.push("Baker couldn't finish bringing in this store's past orders; older periods may be incomplete.");
+  }
+  if (basis === "last_60_days") {
+    hints.push(
+      "Shopify gives Baker this store's last 60 days of orders only: older behaviour is not here, and a buyer whose earlier orders are older counts as new."
+    );
+  }
+  return hints;
+}
+function countriesHints(answer) {
+  const hints = buyerHistoryHints(answer.history, answer.basis);
+  if (answer.total.orders === 0) {
+    hints.push("No orders were placed in this period.");
+    return hints;
+  }
+  hints.push(storeFactsHint(answer.currency));
+  const money = (amount) => `${answer.currency ?? ""} ${amount}`.trim();
+  const growing = answer.rows.filter((row) => row.orders >= MIN_ORDERS_TO_SCALE && (row.ordersGrowth ?? 0) > 0).sort((a, b) => (b.ordersGrowth ?? 0) - (a.ordersGrowth ?? 0))[0];
+  if (growing && answer.level === "country") {
+    hints.push(
+      `Scale ${growing.name}: its orders grew ${percent(growing.ordersGrowth ?? 0)} against the period before (${growing.orders} orders, ${money(growing.net)}). Check which campaigns already target it (\`baker ads meta campaigns\`, \`baker ads google query --preset campaign-performance\`) before staging a change.`
+    );
+  }
+  const average = answer.total.averageOrder;
+  const promising = answer.rows.filter((row) => row.orders < MIN_ORDERS_TO_SCALE && average > 0 && row.averageOrder >= 1.5 * average).sort((a, b) => b.averageOrder - a.averageOrder)[0];
+  if (promising && answer.level === "country") {
+    hints.push(
+      `Test ${promising.name}: its average order is ${money(promising.averageOrder)}, ${(promising.averageOrder / average).toFixed(1)}\xD7 the store's, from only ${promising.orders} orders \u2014 a small budget there would show whether it scales.`
+    );
+  }
+  if (answer.unknown && answer.total.orders > 0 && answer.unknown.orders / answer.total.orders > 0.25) {
+    const lack = answer.level === "country" ? "have no address Baker could read (Unknown)" : `name no ${answer.level} on their address (${answer.unknown.name})`;
+    hints.push(
+      `${answer.unknown.orders} of these orders ${lack}: say so rather than leaving them out of a place's share.`
+    );
+  }
+  return hints;
+}
+function bestSellersHints(answer) {
+  const hints = buyerHistoryHints(answer.history, answer.basis);
+  const leader = answer.repeat?.[0];
+  if (leader && leader.buyersAgain > 0) {
+    hints.push(
+      `Lead a landing with "${leader.title}" (find it with \`baker shopify products --search\`): ${percent(leader.share)} of the buyers whose first order held it came back.`
+    );
+  }
+  const top = answer.products?.[0];
+  if (top && top.units > 0) {
+    hints.push(
+      `"${top.title}" is the best seller (${top.units} units). For which first buys bring buyers back, run \`baker shopify best-sellers --view repeat\`; for what is losing steam, \`--view momentum\`.`
+    );
+  }
+  const losing = answer.momentum?.[0];
+  if (losing) {
+    hints.push(
+      `"${losing.title}" sold ${losing.units} against ${losing.previousUnits} the period before: check its stock (\`baker shopify stock\`) and the ads that promote it before cutting it.`
+    );
+  }
+  const sellers = answer.products ?? answer.variants ?? [];
+  if (sellers.some((row) => row.units > 0)) hints.push(storeFactsHint(answer.currency));
+  const withRefunds = sellers.filter((row) => row.refundedUnits > 0).sort((a, b) => b.refundRate - a.refundRate).slice(0, 5);
+  if (withRefunds.length > 0) {
+    const money = (amount) => `${answer.currency ?? ""} ${amount}`.trim();
+    hints.push(
+      `Refunds: ${withRefunds.map((row) => `"${row.title}" ${percent(row.refundRate)} of units (${money(row.refunded)})`).join(", ")}. Only a product not named here had no refunds in the period.`
+    );
+  }
+  const refunded = answer.products?.find((row) => row.units >= 5 && row.refundRate >= 0.2);
+  if (refunded) {
+    hints.push(
+      `"${refunded.title}" comes back often (${percent(refunded.refundRate)} of units refunded): don't lead a campaign with it before finding out why.`
+    );
+  }
+  return hints;
+}
+function bestBuyersHint(best) {
+  if (!best || best.buyers === 0) return [];
+  const countries = best.topCountries.map((country) => country.name).join(", ");
+  const products = best.topFirstProducts.map((product) => `"${product.title}"`).join(", ");
+  if (!countries && !products) return [];
+  return [
+    `Find more buyers like your best (${best.buyers}): ${countries ? `target ${countries}` : ""}${countries && products ? "; " : ""}${products ? `lead with ${products}, what their first orders held` : ""}.`
+  ];
+}
+function segmentsHints(answer) {
+  const hints = buyerHistoryHints(answer.history, answer.basis);
+  hints.push(...bestBuyersHint(answer.segments.find((segment) => segment.segment === "best")));
+  const atRisk = answer.segments.find((segment) => segment.segment === "at_risk");
+  if (atRisk && atRisk.buyers > 0) {
+    hints.push(
+      `${atRisk.buyers} repeat buyers have not ordered in ${Math.round(2 * answer.thresholds.gapDays)} days (At risk): a win-back offer to them is worth more than a new buyer of the same value.`
+    );
+  }
+  if (answer.buyers > 0) hints.push(AUDIENCE_PATH);
+  return hints;
+}
+function buyersHints(answer) {
+  const hints = buyerHistoryHints(answer.history, answer.basis);
+  if (answer.summary.orders === 0) {
+    hints.push("No orders were placed in this period.");
+    return hints;
+  }
+  hints.push(storeFactsHint(answer.currency));
+  if (answer.acquisition?.by === "campaign" && answer.acquisition.rows.length > 0) {
+    hints.push(
+      "Compare each campaign's lifetime value with what it cost for the same dates (`baker ads meta insights`, `baker ads google query --preset campaign-performance`): Baker keeps no ad spend."
+    );
+  }
+  if (!answer.acquisition) {
+    hints.push(
+      "For lifetime value by the campaign or channel that brought each buyer, add `--by campaign` or `--by channel`."
+    );
+  }
+  if (answer.summary.guestOrders > 0 && answer.summary.guestOrders >= answer.summary.orders / 2) {
+    hints.push(
+      `${answer.summary.guestOrders} of ${answer.summary.orders} orders were placed as guests: they count in sales, never as buyers, so repeat rates read low.`
+    );
+  }
+  if (answer.summary.buyers > 0) hints.push(AUDIENCE_PATH);
+  return hints;
+}
+function cohortsHints(answer) {
+  const hints = buyerHistoryHints(answer.history, answer.basis);
+  const reached = answer.cohorts.filter((cohort) => cohort.retention.m3 !== null && cohort.size >= 5);
+  if (reached.length >= 2) {
+    const best = [...reached].sort((a, b) => (b.retention.m3 ?? 0) - (a.retention.m3 ?? 0))[0];
+    if (best) {
+      hints.push(
+        `Buyers who first ordered in ${best.month} came back best (${percent(best.retention.m3 ?? 0)} ordered again in their third month): look at what was running then (\`baker shopify buyers --by campaign\`).`
+      );
+    }
+  }
+  return hints;
+}
+
+// ../api/src/shopify/buyers.ts
+import { z as z2 } from "zod";
+
+// ../api/src/shopify/wire.ts
+import { z } from "zod";
+var SHOPIFY_NOT_CONNECTED_MESSAGE = "No Shopify store is connected for this company.";
+var SHOPIFY_NOT_OFFERED_MESSAGE = "Baker can't read Shopify stores yet.";
+var SHOPIFY_PRODUCT_NOT_FOUND_PREFIX = "No product matches";
+var shopifyStockStateSchema = z.enum(["in_stock", "partly_out", "out_of_stock"]);
+var shopifyOptionStockSchema = z.enum(["in_stock", "out_of_stock", "not_tracked", "selling_when_out"]);
+var shopifyVisibilitySchema = z.enum(["listed", "link_only", "not_on_store", "no_store"]);
+var shopifyProductStatusSchema = z.enum(["ACTIVE", "ARCHIVED", "DRAFT", "UNLISTED"]);
+var shopifyStoreConnectionSchema = z.enum(["connected", "needs_reconnect", "disconnected"]);
+var shopifyCatalogStateSchema = z.enum(["starting", "importing", "ready", "failed"]);
+var shopifyStorefrontSchema = z.enum(["online_store", "own"]);
+var shopifyAvailabilitySchema = z.enum(["link_only", "not_for_sale"]);
+var shopifyBuyDestinationSchema = z.enum(["checkout", "store_cart", "product_page"]);
+var shopifyBuyNoteSchema = z.enum([
+  "subscription_only",
+  "subscription_optional",
+  "password_protected",
+  "own_storefront",
+  "details_pending"
+]);
+var shopifyUnreadablePartSchema = z.enum(["metaobjects", "definitions", "languages", "policies"]);
+var shopifyStoreStateSchema = z.object({
+  name: z.string(),
+  connection: shopifyStoreConnectionSchema,
+  catalog: shopifyCatalogStateSchema,
+  importProgress: z.object({ done: z.number(), total: z.number().optional() }).optional(),
+  /** Products Baker could not read (it keeps retrying); present only when > 0 and not importing. */
+  unreadable: z.number().optional(),
+  unreadableCapped: z.literal(true).optional(),
+  /** Baker could not check the store for changes lately. */
+  checksFailing: z.literal(true).optional(),
+  storefront: shopifyStorefrontSchema.optional(),
+  /** When Baker last heard from or checked the store — not a promise the copy is current. */
+  lastActivity: z.string().optional()
+});
+var flag = z.enum(["true", "false"]).transform((value) => value === "true");
+var shopifyStoreRequestSchema = z.object({ full: flag.optional() });
+var shopifyProductsRequestSchema = z.object({
+  search: z.string().max(200).optional(),
+  collection: z.string().min(1).max(500).optional(),
+  stock: shopifyStockStateSchema.optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional(),
+  cursor: z.string().optional(),
+  full: flag.optional()
+});
+var SHOPIFY_MAX_BUY_QUANTITY = 99;
+var shopifyProductRequestSchema = z.object({
+  ref: z.string().min(1).max(500),
+  variantsCursor: z.string().optional(),
+  outOfStock: flag.optional(),
+  full: flag.optional(),
+  /** The product's whole details: formatted description, custom fields, subscriptions, translations. */
+  content: flag.optional(),
+  /** One custom field whole, by its name or `namespace.key`. */
+  field: z.string().min(1).max(200).optional(),
+  /** With `field`: the option (its `variantId`) whose field to return, when options share one. */
+  variant: z.string().regex(/^\d{1,30}$/, "an option's variantId").optional(),
+  /** How many of the option each buy link puts in the cart (1-99, default 1). */
+  quantity: z.coerce.number().int().min(1).max(SHOPIFY_MAX_BUY_QUANTITY).optional()
+});
+var shopifyCollectionsRequestSchema = z.object({
+  search: z.string().max(200).optional(),
+  /** Each collection's description, image and SEO. */
+  full: flag.optional()
+});
+var shopifyStockRequestSchema = z.object({
+  collection: z.string().min(1).max(500).optional(),
+  limit: z.coerce.number().int().min(1).max(200).optional(),
+  full: flag.optional()
+});
+var AMOUNT = String.raw`[A-Z]{3} \d+(?:\.\d+)?`;
+var shopifyPriceSchema = z.string().regex(new RegExp(`^${AMOUNT}$`), "a price is '<CURRENCY> <amount>'");
+var shopifyPriceRangeSchema = z.string().regex(new RegExp(`^${AMOUNT}(?: \u2013 ${AMOUNT})?$`), "a price range is '<CURRENCY> <min> \u2013 <CURRENCY> <max>'");
+var SHOPIFY_STOCK_COUNT_CAP = 100;
+var SHOPIFY_COLLECTION_COUNT_CAP = 500;
+var shopifyStoreSummarySchema = z.object({
+  name: z.string(),
+  domain: z.string(),
+  storefrontUrl: z.string().optional(),
+  currency: z.string().optional(),
+  homeCountry: z.string().optional(),
+  products: z.number(),
+  collections: z.number(),
+  outOfStock: z.number(),
+  partlyOut: z.number(),
+  /** A count stopped at its cap: `SHOPIFY_STOCK_COUNT_CAP` for stock counts, `SHOPIFY_COLLECTION_COUNT_CAP` for collections. */
+  capped: z.literal(true).optional(),
+  pricePoints: z.array(
+    z.object({
+      name: z.string(),
+      currency: z.string(),
+      countries: z.array(z.string()),
+      moreCountries: z.number().optional()
+    })
+  ).optional(),
+  productsUrl: z.string(),
+  /** Where the buy links send a shopper (S3b): the store's own setting, checkout unless changed. */
+  buyDestination: shopifyBuyDestinationSchema,
+  /** The store asks for a password before anyone can see it: a buy link meets it first. */
+  passwordProtected: z.literal(true).optional(),
+  /** The store's published languages, primary first. */
+  languages: z.array(z.object({ locale: z.string(), name: z.string(), primary: z.boolean() })).optional(),
+  policies: z.array(
+    z.object({
+      type: z.string(),
+      title: z.string(),
+      url: z.string().optional(),
+      // --full
+      text: z.string().optional()
+    })
+  ).optional(),
+  /** Store content Baker can't read until the store owner accepts Baker's new permissions. */
+  unreadable: z.array(shopifyUnreadablePartSchema).optional(),
+  // --full
+  adminUrl: z.string().optional(),
+  brand: z.object({
+    slogan: z.string().optional(),
+    shortDescription: z.string().optional(),
+    logoUrl: z.string().optional(),
+    squareLogoUrl: z.string().optional(),
+    coverImageUrl: z.string().optional(),
+    colors: z.array(
+      z.object({ role: z.string(), background: z.string().optional(), foreground: z.string().optional() })
+    )
+  }).optional()
+});
+var shopifyStoreResponseSchema = z.object({
+  store: shopifyStoreStateSchema,
+  summary: shopifyStoreSummarySchema,
+  /**
+   * Which store changes Baker may make (S9), by what the store allowed: false
+   * means `baker shopify change …` will ask the user to allow it first.
+   */
+  canChange: z.object({
+    products: z.boolean(),
+    publishing: z.boolean(),
+    discounts: z.boolean(),
+    redirects: z.boolean(),
+    marketing: z.boolean()
+  }).optional()
+});
+var shopifyProductRowSchema = z.object({
+  productId: z.string(),
+  title: z.string(),
+  price: shopifyPriceRangeSchema,
+  compareAt: shopifyPriceRangeSchema.optional(),
+  stock: shopifyStockStateSchema,
+  /** "<out>/<all>" options out of stock, when partly out. */
+  optionsOut: z.string().optional(),
+  availability: shopifyAvailabilitySchema.optional(),
+  status: shopifyProductStatusSchema.optional(),
+  photo: z.enum(["stored", "adding", "none"]),
+  // --full
+  vendor: z.string().optional(),
+  productType: z.string().optional(),
+  variantCount: z.number().optional(),
+  imageUrl: z.string().optional(),
+  visibility: shopifyVisibilitySchema.optional()
+});
+var shopifyProductsResponseSchema = z.object({
+  store: shopifyStoreStateSchema,
+  products: z.array(shopifyProductRowSchema),
+  nextCursor: z.string().nullable()
+});
+var outOptionSchema = z.object({ variantId: z.string(), title: z.string(), sku: z.string().optional() });
+var countryPriceSchema = z.object({
+  name: z.string(),
+  price: shopifyPriceSchema,
+  compareAtPrice: shopifyPriceSchema.optional()
+});
+var shopifyVariantSchema = z.object({
+  variantId: z.string(),
+  title: z.string(),
+  price: shopifyPriceSchema,
+  compareAtPrice: shopifyPriceSchema.optional(),
+  stock: shopifyOptionStockSchema,
+  quantity: z.number().optional(),
+  /** The option's buy link for ads, emails and messages (a landing places `<ShopifyProduct>` instead): never build a Shopify link by hand. Absent when the option can't be bought. */
+  buyUrl: z.string().optional(),
+  buyUrlKind: shopifyBuyDestinationSchema.optional(),
+  /** Why there is no buy link. */
+  unavailable: z.enum(["not_for_sale", "out_of_stock"]).optional(),
+  notes: z.array(shopifyBuyNoteSchema).optional(),
+  // --full
+  checkout: z.string().optional(),
+  storeCart: z.string().optional(),
+  productPage: z.string().optional(),
+  weight: z.string().optional(),
+  unitPrice: z.string().optional(),
+  requiresShipping: z.boolean().optional(),
+  taxable: z.boolean().optional(),
+  sku: z.string().optional(),
+  barcode: z.string().optional(),
+  selectedOptions: z.array(z.object({ name: z.string(), value: z.string() })).optional(),
+  feedId: z.string().optional(),
+  inventoryPolicy: z.enum(["DENY", "CONTINUE"]).optional(),
+  prices: z.array(countryPriceSchema).optional()
+});
+var shopifyProductVideoSchema = z.object({
+  videoId: z.string(),
+  playbackId: z.string(),
+  alt: z.string().optional(),
+  /** Seconds. */
+  duration: z.number().optional()
+});
+var shopifyFieldRefSchema = z.object({
+  kind: z.enum(["image", "file", "video", "product", "variant", "collection", "metaobject", "other"]),
+  id: z.string(),
+  url: z.string().optional(),
+  mimeType: z.string().optional(),
+  alt: z.string().optional(),
+  /** A video's preview image; its `url` is the video file itself. */
+  previewUrl: z.string().optional(),
+  /** A product's or a collection's title, from Baker's copy. */
+  title: z.string().optional(),
+  /** An image brought into the library: its imageId, to place like the product's photos. */
+  imageId: z.string().optional(),
+  /** A custom content entry (a size chart, a care guide): its name and fields. */
+  entry: z.object({
+    name: z.string(),
+    fields: z.array(z.object({ name: z.string(), text: z.string(), truncated: z.literal(true).optional() }))
+  }).optional()
+});
+var shopifyProductFieldSchema = z.object({
+  name: z.string(),
+  /** `namespace.key`: what `--field` takes when two fields share a name. */
+  key: z.string(),
+  type: z.string(),
+  owner: z.enum(["product", "option"]),
+  variantId: z.string().optional(),
+  text: z.string(),
+  html: z.string().optional(),
+  refs: z.array(shopifyFieldRefSchema).optional(),
+  refsMore: z.number().optional(),
+  /** The text or the list is longer than shown: `--field <key>` returns it whole. */
+  truncated: z.literal(true).optional(),
+  /** The store owner hasn't let Baker read what this field points at yet. */
+  unreadable: z.literal(true).optional()
+});
+var shopifyProductContentSchema = z.object({
+  descriptionHtml: z.string(),
+  descriptionTruncated: z.literal(true).optional(),
+  category: z.string().optional(),
+  giftCard: z.literal(true).optional(),
+  fields: z.array(shopifyProductFieldSchema),
+  rating: z.object({ value: z.number(), scaleMax: z.number(), count: z.number().optional() }).optional(),
+  /** Subscriptions the product can be bought with; `subscriptionOnly` when only by subscription. */
+  subscriptions: z.array(
+    z.object({ name: z.string(), plans: z.array(z.object({ name: z.string(), category: z.string().optional() })) })
+  ).optional(),
+  subscriptionOnly: z.literal(true).optional(),
+  /** YouTube or Vimeo videos and 3D models: links with their preview image. */
+  mediaLinks: z.array(
+    z.object({
+      kind: z.enum(["external_video", "model_3d"]),
+      url: z.string(),
+      embedUrl: z.string().optional(),
+      previewUrl: z.string().optional(),
+      alt: z.string().optional()
+    })
+  ),
+  bundle: z.array(z.object({ productId: z.string(), title: z.string().optional(), quantity: z.number() })).optional(),
+  combinedListing: z.object({ role: z.string(), parentProductId: z.string().optional(), childProductIds: z.array(z.string()) }).optional(),
+  translations: z.array(
+    z.object({
+      locale: z.string(),
+      title: z.string().optional(),
+      description: z.string().optional(),
+      seoTitle: z.string().optional(),
+      seoDescription: z.string().optional(),
+      options: z.array(
+        z.object({
+          name: z.string(),
+          translatedName: z.string().optional(),
+          values: z.array(z.object({ value: z.string(), translated: z.string().optional() }))
+        })
+      ),
+      truncated: z.literal(true).optional()
+    })
+  ),
+  /** Content the store owner hasn't let Baker read yet. */
+  unreadable: z.array(shopifyUnreadablePartSchema).optional(),
+  /** Baker hasn't read this product's details yet, or Shopify didn't send some of them. */
+  pending: z.literal(true).optional(),
+  failure: z.string().optional()
+});
+var shopifyProductDetailSchema = z.object({
+  productId: z.string(),
+  title: z.string(),
+  handle: z.string(),
+  /** The product's page in Baker — the link to share with the user. */
+  url: z.string(),
+  /** The product's page on the online store: to look at, never a buy button's link (that is each option's `buyUrl`, or `<ShopifyProduct>` on a landing). */
+  storeUrl: z.string().optional(),
+  availability: shopifyAvailabilitySchema.optional(),
+  status: shopifyProductStatusSchema.optional(),
+  vendor: z.string(),
+  productType: z.string(),
+  price: shopifyPriceRangeSchema,
+  compareAt: shopifyPriceRangeSchema.optional(),
+  stock: z.object({ state: shopifyStockStateSchema, optionsOut: z.number(), options: z.number() }),
+  outOptions: z.array(outOptionSchema),
+  outOptionsMore: z.number().optional(),
+  options: z.array(z.object({ name: z.string(), values: z.array(z.string()) })),
+  variants: z.array(shopifyVariantSchema),
+  variantTotal: z.number(),
+  variantsNextCursor: z.string().optional(),
+  photos: z.array(z.object({ imageId: z.string(), url: z.string(), alt: z.string().optional() })),
+  photosAdding: z.number(),
+  photosNotBrought: z.number(),
+  collections: z.array(z.object({ collectionId: z.string(), title: z.string() })),
+  description: z.string(),
+  descriptionTruncated: z.literal(true).optional(),
+  tags: z.array(z.string()),
+  pricesByCountry: z.array(
+    z.object({
+      name: z.string(),
+      price: shopifyPriceRangeSchema,
+      countries: z.array(z.string()),
+      moreCountries: z.number().optional()
+    })
+  ).optional(),
+  /** When Baker last read this product from the store. */
+  observedAt: z.string(),
+  /** What else Baker keeps about it, in a line: "formatted description, 2 videos, Size chart, 4.7★ from 120 reviews". */
+  contentSummary: z.string().optional(),
+  /** Its Shopify videos in the video library: place one with `<Video playbackId=…/>`. */
+  videos: z.array(shopifyProductVideoSchema),
+  videosAdding: z.number(),
+  videosNotBrought: z.number(),
+  /** Where the buy links send a shopper, and how many each puts in the cart. */
+  buyDestination: shopifyBuyDestinationSchema,
+  quantity: z.number(),
+  /** --content (or --full): the whole of it. */
+  content: shopifyProductContentSchema.optional(),
+  /** --field: one custom field, whole. */
+  field: shopifyProductFieldSchema.optional(),
+  // --full
+  visibility: shopifyVisibilitySchema.optional(),
+  seo: z.object({ title: z.string().optional(), description: z.string().optional() }).optional(),
+  category: z.string().optional(),
+  adminUrl: z.string().optional()
+});
+var shopifyProductResponseSchema = z.object({
+  store: shopifyStoreStateSchema,
+  product: shopifyProductDetailSchema
+});
+var shopifyCollectionRowSchema = z.object({
+  collectionId: z.string(),
+  title: z.string(),
+  handle: z.string(),
+  /** Shopify's count at Baker's last read. */
+  products: z.number(),
+  onStore: z.boolean().optional(),
+  // --full
+  description: z.string().optional(),
+  imageUrl: z.string().optional(),
+  seo: z.object({ title: z.string().optional(), description: z.string().optional() }).optional()
+});
+var shopifyCollectionsResponseSchema = z.object({
+  store: shopifyStoreStateSchema,
+  collections: z.array(shopifyCollectionRowSchema)
+});
+var shopifyOutOfStockRowSchema = z.object({
+  productId: z.string(),
+  title: z.string(),
+  options: z.number(),
+  // --full
+  url: z.string().optional()
+});
+var shopifyPartlyOutRowSchema = z.object({
+  productId: z.string(),
+  title: z.string(),
+  optionsOut: z.number(),
+  options: z.number(),
+  outOptions: z.array(outOptionSchema),
+  outOptionsMore: z.number().optional(),
+  // --full
+  url: z.string().optional()
+});
+var shopifyStockResponseSchema = z.object({
+  store: shopifyStoreStateSchema,
+  outOfStock: z.array(shopifyOutOfStockRowSchema),
+  partlyOut: z.array(shopifyPartlyOutRowSchema),
+  /** More products in that group than `limit`. */
+  more: z.object({ outOfStock: z.boolean(), partlyOut: z.boolean() })
+});
+var shopifySalesBySchema = z.enum([
+  "day",
+  "product",
+  "campaign",
+  "landing",
+  "weekday",
+  "hour",
+  "month",
+  "month_of_year"
+]);
+var SHOPIFY_SALES_TIMING_BY = ["weekday", "hour", "month", "month_of_year"];
+var SHOPIFY_SALES_MAX_DAYS = 395;
+var SHOPIFY_SALES_TIMING_MAX_DAYS = 3650;
+var shopifySalesRequestSchema = z.object({
+  days: z.coerce.number().int().min(1).max(SHOPIFY_SALES_TIMING_MAX_DAYS).optional(),
+  /** Every order the store has (timing breakdowns only). */
+  all: flag.optional(),
+  by: shopifySalesBySchema.optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional(),
+  full: flag.optional()
+}).superRefine((request, ctx) => {
+  if (SHOPIFY_SALES_TIMING_BY.includes(request.by ?? "day")) return;
+  if (request.all) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["all"],
+      message: "all is only for --by weekday, hour, month or month_of_year"
+    });
+  }
+  if ((request.days ?? 0) > SHOPIFY_SALES_MAX_DAYS) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["days"],
+      message: `by day, product, campaign or landing reads up to ${SHOPIFY_SALES_MAX_DAYS} days`
+    });
+  }
+});
+var shopifySalesCreditSchema = z.enum([
+  "campaign",
+  "order",
+  "landing",
+  "before_baker",
+  "unattributed",
+  "other"
+]);
+var shopifySalesRowSchema = z.object({
+  /** A campaign, a landing's name, a day (YYYY-MM-DD) or a product's title. */
+  label: z.string(),
+  credit: shopifySalesCreditSchema.optional(),
+  orders: z.number(),
+  sales: z.number(),
+  refunded: z.number(),
+  net: z.number(),
+  /** By day: money received after the sale (an edit paid for). */
+  added: z.number().optional(),
+  /** By product: units sold and given back. */
+  units: z.number().optional(),
+  refundedUnits: z.number().optional(),
+  /** By weekday, hour or month: the buyers who ordered. */
+  buyers: z.number().optional(),
+  // --full
+  source: z.string().optional(),
+  medium: z.string().optional(),
+  campaign: z.string().optional(),
+  /** The ad platform of the click that brought the buyer: google, meta, linkedin, … */
+  clickPlatform: z.string().optional(),
+  landingId: z.string().optional(),
+  productId: z.string().optional()
+});
+var shopifySalesTotalsSchema = z.object({
+  orders: z.number(),
+  /** What the orders came to, with money added after the sale. */
+  sales: z.number(),
+  added: z.number(),
+  refunded: z.number(),
+  net: z.number()
+});
+var shopifySalesReportingSchema = z.enum(["shopify_channel", "baker", "undecided"]);
+var shopifySalesResponseSchema = z.object({
+  store: shopifyStoreStateSchema,
+  /** `days` is "all" with `all`; `timezone` names the store's time a timing breakdown was read in. */
+  window: z.object({
+    days: z.union([z.number(), z.literal("all")]),
+    from: z.string(),
+    to: z.string(),
+    timezone: z.string().optional()
+  }),
+  by: shopifySalesBySchema,
+  /** The store's currency; null when nothing sold in the window. */
+  currency: z.string().nullable(),
+  totals: shopifySalesTotalsSchema,
+  rows: z.array(shopifySalesRowSchema),
+  /** Sales in another currency, which are never added to these. */
+  otherCurrencies: z.array(z.object({ currency: z.string(), net: z.number() })).optional(),
+  salesReporting: z.object({ meta: shopifySalesReportingSchema, google: shopifySalesReportingSchema }),
+  /** The order history Baker imports when a store connects: still coming in, done, or failed. */
+  history: z.enum(["importing", "done", "failed", "none"]),
+  /** Baker could not read this store's orders (the store must be reconnected). */
+  ordersUnreadable: z.literal(true).optional()
+});
+
+// ../api/src/shopify/buyers.ts
+var flag2 = z2.enum(["true", "false"]).transform((value) => value === "true");
+var SHOPIFY_STORE_WINDOW_MAX_DAYS = 3650;
+var days = z2.coerce.number().int().min(1).max(SHOPIFY_STORE_WINDOW_MAX_DAYS);
+var countryCode = z2.string().regex(/^[A-Za-z]{2}$/, "a two-letter country code, like DE").transform((value) => value.toUpperCase());
+var limit = z2.coerce.number().int().min(1).max(100);
+var windowRequest = {
+  days: days.optional(),
+  /** Every order the store has. */
+  all: flag2.optional(),
+  country: countryCode.optional(),
+  full: flag2.optional()
+};
+var shopifyStoreWindowSchema = z2.object({
+  from: z2.string().nullable(),
+  to: z2.string(),
+  days: z2.union([z2.number(), z2.literal("all")]),
+  timezone: z2.string()
+});
+var shopifyBuyerHistorySchema = z2.object({
+  state: z2.enum(["importing", "done", "failed", "none"]),
+  reach: z2.enum(["all", "60_days"]).nullable(),
+  /** The day of the oldest order Baker holds (YYYY-MM-DD). */
+  from: z2.string().nullable(),
+  /** Orders brought in so far. */
+  orders: z2.number()
+});
+var shopifyBuyerBasisSchema = z2.enum(["all_orders", "last_60_days"]);
+var answerCommon = {
+  store: shopifyStoreStateSchema,
+  window: shopifyStoreWindowSchema,
+  /** The store's currency; null when it has no orders yet. */
+  currency: z2.string().nullable(),
+  /** Orders in another currency (the store changed currency), never added to these. */
+  otherCurrencies: z2.array(z2.object({ currency: z2.string(), orders: z2.number(), net: z2.number() })).optional(),
+  history: shopifyBuyerHistorySchema,
+  basis: shopifyBuyerBasisSchema
+};
+var shopifyPlaceSchema = z2.object({
+  country: z2.string(),
+  countryName: z2.string(),
+  region: z2.string(),
+  city: z2.string()
+});
+var shopifyBuyerSegmentSchema = z2.enum(["best", "loyal", "at_risk", "new", "one_time"]);
+var shopifySegmentThresholdsSchema = z2.object({
+  /** The store's typical days between a repeat buyer's orders (90 with too few to go on). */
+  gapDays: z2.number(),
+  /** The lifetime net that puts a buyer in the top fifth. */
+  netP80: z2.number()
+});
+var shopifySegmentRowSchema = z2.object({
+  segment: shopifyBuyerSegmentSchema,
+  label: z2.string(),
+  /** The rule in words, with this store's numbers. */
+  rule: z2.string(),
+  buyers: z2.number(),
+  /** Of every buyer, 0–1. */
+  share: z2.number(),
+  net: z2.number(),
+  averageOrders: z2.number(),
+  averageDaysSinceLastOrder: z2.number(),
+  topCountries: z2.array(z2.object({ code: z2.string(), name: z2.string(), buyers: z2.number() })),
+  /** The products their first orders held most often. */
+  topFirstProducts: z2.array(z2.object({ title: z2.string(), buyers: z2.number(), productId: z2.string().optional() }))
+});
+var shopifySegmentsRequestSchema = z2.object({ ...windowRequest });
+var shopifySegmentsResponseSchema = z2.object({
+  ...answerCommon,
+  thresholds: shopifySegmentThresholdsSchema,
+  buyers: z2.number(),
+  segments: z2.array(shopifySegmentRowSchema)
+});
+var shopifyBuyersSortSchema = z2.enum(["net", "orders", "recent", "first"]);
+var shopifyAcquisitionBySchema = z2.enum(["campaign", "channel"]);
+var shopifyBuyersRequestSchema = z2.object({
+  ...windowRequest,
+  segment: shopifyBuyerSegmentSchema.optional(),
+  /** Lifetime value by the campaign or channel of each buyer's first order. */
+  by: shopifyAcquisitionBySchema.optional(),
+  /** Only buyers whose first order came through this channel (a key from `by=channel`). */
+  channel: z2.string().max(200).optional(),
+  sort: shopifyBuyersSortSchema.optional(),
+  limit: limit.optional(),
+  offset: z2.coerce.number().int().min(0).max(1e5).optional()
+});
+var shopifyBuyersSummarySchema = z2.object({
+  /** Buyers who ordered in the period. */
+  buyers: z2.number(),
+  /** Of them, whose first order was in the period. */
+  newBuyers: z2.number(),
+  returningBuyers: z2.number(),
+  /** Orders with no customer: counted in money, never a buyer. */
+  guestOrders: z2.number(),
+  orders: z2.number(),
+  net: z2.number(),
+  averageOrder: z2.number(),
+  /** Orders that were their buyer's first, and the rest (Shopify's new vs returning). */
+  newOrders: z2.number(),
+  returningOrders: z2.number(),
+  newNet: z2.number(),
+  returningNet: z2.number(),
+  /** Of every buyer up to the period's end, the share who ordered again (0–1). */
+  repeatRate: z2.number(),
+  /** Median days from a buyer's first order to their second; null when nobody ordered twice. */
+  medianDaysToSecond: z2.number().nullable()
+});
+var shopifyCameFromSchema = z2.object({
+  channel: z2.string(),
+  label: z2.string(),
+  campaign: z2.string().optional(),
+  // --full
+  source: z2.string().optional(),
+  medium: z2.string().optional(),
+  clickPlatform: z2.string().optional(),
+  landingId: z2.string().optional()
+});
+var shopifyBuyerRowSchema = z2.object({
+  number: z2.number(),
+  /** "Customer #1042". */
+  label: z2.string(),
+  place: shopifyPlaceSchema.nullable(),
+  orders: z2.number(),
+  net: z2.number(),
+  firstOrderAt: z2.string(),
+  lastOrderAt: z2.string(),
+  segment: shopifyBuyerSegmentSchema,
+  cameFrom: shopifyCameFromSchema,
+  // --full
+  gross: z2.number().optional(),
+  refunded: z2.number().optional(),
+  ordersWithDiscount: z2.number().optional(),
+  averageDaysBetweenOrders: z2.number().nullable().optional()
+});
+var shopifyAcquisitionRowSchema = z2.object({
+  key: z2.string(),
+  label: z2.string(),
+  buyers: z2.number(),
+  /** What their first orders came to. */
+  firstNet: z2.number(),
+  /** What they have spent since, to date. */
+  lifetimeNet: z2.number(),
+  lifetimePerBuyer: z2.number(),
+  averageOrders: z2.number(),
+  repeatRate: z2.number(),
+  // --full
+  source: z2.string().optional(),
+  medium: z2.string().optional(),
+  campaign: z2.string().optional(),
+  clickPlatform: z2.string().optional()
+});
+var shopifyBuyersResponseSchema = z2.object({
+  ...answerCommon,
+  summary: shopifyBuyersSummarySchema,
+  thresholds: shopifySegmentThresholdsSchema,
+  segments: z2.array(z2.object({ segment: shopifyBuyerSegmentSchema, label: z2.string(), buyers: z2.number() })),
+  /** Buyers matching the filters, before the limit. */
+  total: z2.number(),
+  buyers: z2.array(shopifyBuyerRowSchema),
+  acquisition: z2.object({ by: shopifyAcquisitionBySchema, rows: z2.array(shopifyAcquisitionRowSchema) }).optional()
+});
+var shopifyBuyerNumberSchema = z2.string().trim().transform((value) => value.replace(/^customer\s*/i, "").replace(/^#/, "")).pipe(z2.string().regex(/^\d+$/, "a buyer's number, like 1042 or #1042")).transform((value) => Number(value)).pipe(z2.number().int().min(1).max(4e9));
+var shopifyBuyerRequestSchema = z2.object({ number: shopifyBuyerNumberSchema, full: flag2.optional() });
+var SHOPIFY_BUYER_GONE_MESSAGE = "This buyer is no longer in Baker.";
+var shopifyBuyerOrderSchema = z2.object({
+  name: z2.string(),
+  /** When it was placed, in the store's time (YYYY-MM-DD HH:MM). */
+  placedAt: z2.string(),
+  net: z2.number(),
+  gross: z2.number(),
+  refunded: z2.number(),
+  products: z2.array(z2.object({ title: z2.string(), quantity: z2.number() })),
+  discountCodes: z2.array(z2.string()),
+  place: shopifyPlaceSchema.nullable(),
+  /** Placed before Baker measured the store: counted, credited to no campaign. */
+  beforeBaker: z2.boolean(),
+  // --full
+  orderId: z2.string().optional(),
+  items: z2.array(z2.object({ productId: z2.string(), variantId: z2.string(), quantity: z2.number(), amount: z2.number() })).optional(),
+  refundedItems: z2.array(z2.object({ productId: z2.string(), variantId: z2.string(), quantity: z2.number(), amount: z2.number() })).optional(),
+  cameFrom: shopifyCameFromSchema.optional()
+});
+var shopifyBuyerProfileSchema = z2.object({
+  number: z2.number(),
+  label: z2.string(),
+  place: shopifyPlaceSchema.nullable(),
+  orders: z2.number(),
+  gross: z2.number(),
+  refunded: z2.number(),
+  net: z2.number(),
+  averageOrder: z2.number(),
+  /** Average days between their orders; null with one order. */
+  averageDaysBetweenOrders: z2.number().nullable(),
+  firstOrderAt: z2.string(),
+  lastOrderAt: z2.string(),
+  ordersWithDiscount: z2.number(),
+  segment: shopifyBuyerSegmentSchema,
+  segmentLabel: z2.string(),
+  cameFrom: shopifyCameFromSchema
+});
+var shopifyBuyerResponseSchema = z2.object({
+  ...answerCommon,
+  buyer: shopifyBuyerProfileSchema,
+  /** Newest first. */
+  orders: z2.array(shopifyBuyerOrderSchema),
+  products: z2.array(
+    z2.object({ title: z2.string(), quantity: z2.number(), orders: z2.number(), productId: z2.string().optional() })
+  )
+});
+var shopifyCountriesRequestSchema = z2.object({
+  ...windowRequest,
+  /** Inside one region of `country` (its code or name): its cities. */
+  region: z2.string().max(100).optional(),
+  /** Only orders holding this product (its id or handle); money is that product's lines. */
+  product: z2.string().max(255).optional(),
+  limit: limit.optional()
+});
+var shopifyPlaceRowSchema = z2.object({
+  /** A country code, a region code (or name) or a city. */
+  key: z2.string(),
+  name: z2.string(),
+  orders: z2.number(),
+  buyers: z2.number(),
+  newBuyers: z2.number(),
+  net: z2.number(),
+  averageOrder: z2.number(),
+  /** Of the total's net, 0–1. */
+  share: z2.number(),
+  /** Net against the period before; null when there was none before. */
+  growth: z2.number().nullable(),
+  ordersGrowth: z2.number().nullable(),
+  /** The currency its buyers paid in most. */
+  paidIn: z2.string(),
+  // --full
+  previousNet: z2.number().optional(),
+  previousOrders: z2.number().optional()
+});
+var shopifyCountriesResponseSchema = z2.object({
+  ...answerCommon,
+  level: z2.enum(["country", "region", "city"]),
+  country: z2.string().optional(),
+  region: z2.string().optional(),
+  product: z2.object({ id: z2.string(), title: z2.string() }).optional(),
+  total: shopifyPlaceRowSchema,
+  /** Named places, best first; with `unknown` and `other` they add up to `total`. */
+  rows: z2.array(shopifyPlaceRowSchema),
+  /** Orders whose address Baker could not read. Always shown, never folded into `other`. */
+  unknown: shopifyPlaceRowSchema.nullable(),
+  /** Places past the limit, together. */
+  other: shopifyPlaceRowSchema.nullable()
+});
+var shopifyBestSellersViewSchema = z2.enum(["products", "variants", "trend", "together", "repeat", "momentum"]);
+var shopifyBestSellersSortSchema = z2.enum(["units", "revenue", "orders"]);
+var shopifyBestSellersRequestSchema = z2.object({
+  ...windowRequest,
+  view: shopifyBestSellersViewSchema.optional(),
+  sort: shopifyBestSellersSortSchema.optional(),
+  /** Only this product (its id or handle): its variants, its trend. */
+  product: z2.string().max(255).optional(),
+  limit: limit.optional()
+});
+var shopifyBestSellerRowSchema = z2.object({
+  title: z2.string(),
+  /** The option's own title, by variant. */
+  variantTitle: z2.string().optional(),
+  units: z2.number(),
+  refundedUnits: z2.number(),
+  orders: z2.number(),
+  buyers: z2.number(),
+  revenue: z2.number(),
+  refunded: z2.number(),
+  /** Refunded units of units ordered, 0–1. */
+  refundRate: z2.number(),
+  /** Units against the period before; null when none sold before. */
+  growth: z2.number().nullable(),
+  // --full
+  productId: z2.string().optional(),
+  variantId: z2.string().optional(),
+  previousUnits: z2.number().optional(),
+  previousRevenue: z2.number().optional()
+});
+var shopifyTrendRowSchema = z2.object({
+  /** YYYY-MM, in the store's time. */
+  month: z2.string(),
+  title: z2.string(),
+  units: z2.number(),
+  revenue: z2.number(),
+  productId: z2.string().optional()
+});
+var shopifyTogetherRowSchema = z2.object({
+  first: z2.string(),
+  second: z2.string(),
+  /** Orders holding both. */
+  orders: z2.number(),
+  /** Of the orders holding the first, the share that also held the second (0–1). */
+  confidence: z2.number(),
+  firstId: z2.string().optional(),
+  secondId: z2.string().optional()
+});
+var shopifyRepeatRowSchema = z2.object({
+  title: z2.string(),
+  /** Buyers whose first order held it. */
+  buyers: z2.number(),
+  /** Of them, who ordered again. */
+  buyersAgain: z2.number(),
+  share: z2.number(),
+  medianDaysToSecond: z2.number().nullable(),
+  productId: z2.string().optional()
+});
+var shopifyMomentumRowSchema = z2.object({
+  title: z2.string(),
+  units: z2.number(),
+  previousUnits: z2.number(),
+  /** Units against the period before (−0.4 = 40% fewer). */
+  change: z2.number(),
+  revenue: z2.number(),
+  productId: z2.string().optional()
+});
+var shopifyBestSellersResponseSchema = z2.object({
+  ...answerCommon,
+  view: shopifyBestSellersViewSchema,
+  sort: shopifyBestSellersSortSchema,
+  product: z2.object({ id: z2.string(), title: z2.string() }).optional(),
+  products: z2.array(shopifyBestSellerRowSchema).optional(),
+  variants: z2.array(shopifyBestSellerRowSchema).optional(),
+  trend: z2.array(shopifyTrendRowSchema).optional(),
+  together: z2.array(shopifyTogetherRowSchema).optional(),
+  repeat: z2.array(shopifyRepeatRowSchema).optional(),
+  momentum: z2.array(shopifyMomentumRowSchema).optional()
+});
+var shopifyCohortsRequestSchema = z2.object({
+  months: z2.coerce.number().int().min(3).max(36).optional(),
+  country: countryCode.optional(),
+  full: flag2.optional()
+});
+var shopifyCohortMonthSchema = z2.object({
+  /** Months since the first order: 0 is the month they first bought. */
+  offset: z2.number(),
+  activeBuyers: z2.number(),
+  orders: z2.number(),
+  net: z2.number(),
+  /** Of the cohort, who ordered in that month (0–1). */
+  retention: z2.number(),
+  /** What the cohort spent up to that month, per buyer. */
+  cumulativeNetPerBuyer: z2.number()
+});
+var shopifyCohortSchema = z2.object({
+  /** The month of their first order, YYYY-MM in the store's time. */
+  month: z2.string(),
+  size: z2.number(),
+  /** Who ordered again 1, 2, 3, 6 and 12 months after; null for a month not reached yet. */
+  retention: z2.object({
+    m1: z2.number().nullable(),
+    m2: z2.number().nullable(),
+    m3: z2.number().nullable(),
+    m6: z2.number().nullable(),
+    m12: z2.number().nullable()
+  }),
+  netPerBuyerAt12: z2.number().nullable(),
+  // --full
+  matrix: z2.array(shopifyCohortMonthSchema).optional()
+});
+var shopifyCohortsResponseSchema = z2.object({
+  ...answerCommon,
+  months: z2.number(),
+  cohorts: z2.array(shopifyCohortSchema)
+});
+
+// ../api/src/shopify/writes.ts
+import { z as z3 } from "zod";
+var SHOPIFY_TEMP_REF_PREFIX = "shopify_temp_";
+var SHOPIFY_PERMISSION_NEEDED_PREFIX = "Baker isn't allowed to change this Shopify store yet";
+var shopifyWriteEntitySchema = z3.enum([
+  "product",
+  "variant",
+  "metafield",
+  "collection",
+  "discountCode",
+  "urlRedirect",
+  "marketingActivity",
+  "webPixel",
+  "signupOffer"
+]);
+var shopifyDraftOpKindSchema = z3.enum([
+  "shopify.product.update",
+  "shopify.variant.update",
+  "shopify.metafield.set",
+  "shopify.metafield.delete",
+  "shopify.collection.create",
+  "shopify.collection.publish",
+  "shopify.collection.unpublish",
+  "shopify.collection.update",
+  "shopify.collection.delete",
+  "shopify.collection.addProducts",
+  "shopify.collection.removeProducts",
+  "shopify.discountCode.create",
+  "shopify.discountCode.deactivate",
+  "shopify.discountCode.schedule",
+  "shopify.urlRedirect.create",
+  "shopify.urlRedirect.delete",
+  "shopify.marketingActivity.upsert",
+  "shopify.marketingActivity.delete",
+  "shopify.webPixel.update",
+  "shopify.signupOffer.set",
+  "shopify.signupOffer.end"
+]);
+var shopifyDecimalSchema = z3.string().regex(/^\d{1,12}(\.\d{1,4})?$/, 'write amounts as a decimal string, e.g. "19.95"');
+var tagSchema = z3.string().trim().min(1).max(255);
+var seoSchema = z3.object({ title: z3.string().max(255).optional(), description: z3.string().max(320).optional() }).strict();
+var SHOPIFY_DESCRIPTION_MAX_CHARS = 2e5;
+var descriptionHtmlSchema = z3.string().max(SHOPIFY_DESCRIPTION_MAX_CHARS);
+var productUpdateSchema = z3.object({
+  title: z3.string().trim().min(1).max(255).optional(),
+  descriptionHtml: descriptionHtmlSchema.optional(),
+  seo: seoSchema.optional(),
+  /** The WHOLE tag list after the change (Shopify replaces it). `addTags`/`removeTags` are resolved against the live tags. */
+  tags: z3.array(tagSchema).max(250).optional(),
+  addTags: z3.array(tagSchema).max(250).optional(),
+  removeTags: z3.array(tagSchema).max(250).optional(),
+  productType: z3.string().max(255).optional()
+}).strict().refine((payload) => Object.keys(payload).length > 0, "name at least one thing to change").refine(
+  (payload) => payload.tags === void 0 || payload.addTags === void 0 && payload.removeTags === void 0,
+  "give either the whole `tags` list or `addTags`/`removeTags`, not both"
+);
+var shopifyWeightUnitSchema = z3.enum(["GRAMS", "KILOGRAMS", "OUNCES", "POUNDS"]);
+var variantUpdateSchema = z3.object({
+  barcode: z3.string().trim().max(255).optional(),
+  sku: z3.string().trim().max(255).optional(),
+  weight: z3.object({ value: z3.number().nonnegative(), unit: shopifyWeightUnitSchema }).strict().optional(),
+  price: shopifyDecimalSchema.optional(),
+  /** `null` clears the sale ("compare at") price. */
+  compareAtPrice: shopifyDecimalSchema.nullable().optional()
+}).strict().refine((payload) => Object.keys(payload).length > 0, "name at least one thing to change");
+var metafieldKeySchema = z3.string().min(2).max(64).regex(/^[A-Za-z0-9_-]+$/, "letters, digits, `_` and `-` only");
+var metafieldNamespaceSchema = z3.string().min(2).max(255).regex(/^[A-Za-z0-9_-]+$/, "letters, digits, `_` and `-` only");
+var metafieldSetSchema = z3.object({
+  namespace: metafieldNamespaceSchema,
+  key: metafieldKeySchema,
+  /** Shopify's metafield type, e.g. `single_line_text_field`, `multi_line_text_field`, `rich_text_field`, `number_integer`, `boolean`, `json`. */
+  type: z3.string().min(1).max(100),
+  value: z3.string().max(1e5)
+}).strict();
+var metafieldDeleteSchema = z3.object({ namespace: metafieldNamespaceSchema, key: metafieldKeySchema }).strict();
+var shopifyCollectionSortOrderSchema = z3.enum([
+  "MANUAL",
+  "BEST_SELLING",
+  "ALPHA_ASC",
+  "ALPHA_DESC",
+  "PRICE_DESC",
+  "PRICE_ASC",
+  "CREATED",
+  "CREATED_DESC"
+]);
+var handleSchema = z3.string().min(1).max(255).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "lowercase letters, digits and single dashes, e.g. summer-snowboards");
+var SHOPIFY_COLLECTION_PRODUCTS_MAX = 250;
+var collectionCreateSchema = z3.object({
+  title: z3.string().trim().min(1).max(255),
+  handle: handleSchema.optional(),
+  descriptionHtml: descriptionHtmlSchema.optional(),
+  seo: seoSchema.optional(),
+  sortOrder: shopifyCollectionSortOrderSchema.optional(),
+  /** The theme template the collection page uses (the part after `collection.`). Kept when a deleted collection is put back. */
+  templateSuffix: z3.string().max(255).optional(),
+  /** Product ids, handles or links, in the order shown with sort order MANUAL. */
+  products: z3.array(z3.string().min(1)).max(SHOPIFY_COLLECTION_PRODUCTS_MAX).optional(),
+  /** Show it on the online store (a second change, staged with it). Default true. */
+  onlineStore: z3.boolean().optional()
+}).strict();
+var collectionUpdateSchema = z3.object({
+  title: z3.string().trim().min(1).max(255).optional(),
+  descriptionHtml: descriptionHtmlSchema.optional(),
+  seo: seoSchema.optional(),
+  sortOrder: shopifyCollectionSortOrderSchema.optional()
+}).strict().refine((payload) => Object.keys(payload).length > 0, "name at least one thing to change");
+var collectionProductsSchema = z3.object({ products: z3.array(z3.string().min(1)).min(1).max(SHOPIFY_COLLECTION_PRODUCTS_MAX) }).strict();
+var isoDateTimeSchema = z3.iso.datetime({ offset: true });
+var discountCodeSchema = z3.string().regex(/^[A-Za-z0-9_-]{3,64}$/, "3\u201364 letters, digits, `_` or `-`, e.g. SPRING10");
+var discountValueSchema = z3.union([
+  z3.object({ percentage: z3.number().min(1).max(100) }).strict(),
+  z3.object({ amount: shopifyDecimalSchema }).strict()
+]);
+var discountAppliesToSchema = z3.union([
+  z3.object({ all: z3.literal(true) }).strict(),
+  z3.object({ products: z3.array(z3.string().min(1)).min(1).max(100) }).strict(),
+  z3.object({ collections: z3.array(z3.string().min(1)).min(1).max(100) }).strict()
+]);
+var discountCreateSchema = z3.object({
+  code: discountCodeSchema,
+  /** What the store's staff see; defaults to the code. */
+  title: z3.string().trim().min(1).max(255).optional(),
+  value: discountValueSchema,
+  appliesTo: discountAppliesToSchema,
+  minimumSubtotal: shopifyDecimalSchema.optional(),
+  minimumQuantity: z3.number().int().min(1).max(1e4).optional(),
+  /** Default: the moment it is published. */
+  startsAt: isoDateTimeSchema.optional(),
+  endsAt: isoDateTimeSchema.optional(),
+  usageLimit: z3.number().int().min(1).max(1e6).optional(),
+  /** Default true. */
+  oncePerCustomer: z3.boolean().optional(),
+  combinesWith: z3.object({
+    productDiscounts: z3.boolean().optional(),
+    orderDiscounts: z3.boolean().optional(),
+    shippingDiscounts: z3.boolean().optional()
+  }).strict().optional()
+}).strict().refine(
+  (payload) => payload.minimumSubtotal === void 0 || payload.minimumQuantity === void 0,
+  "a discount takes a minimum amount or a minimum quantity, not both"
+);
+var discountScheduleSchema = z3.object({ startsAt: isoDateTimeSchema, endsAt: isoDateTimeSchema.nullable() }).strict();
+var storePathSchema = z3.string().min(2).max(1024).regex(/^\/[^\s]*$/, 'a path on the store starting with "/", e.g. /collections/old');
+var urlRedirectCreateSchema = z3.object({
+  from: storePathSchema,
+  to: z3.union([storePathSchema, z3.url({ protocol: /^https$/ })])
+}).strict();
+var shopifyMarketingPlatformSchema = z3.enum(["google-ads", "meta"]);
+var marketingUpsertSchema = z3.object({
+  platform: shopifyMarketingPlatformSchema,
+  accountId: z3.string().min(1).max(64),
+  campaignId: z3.string().regex(/^\d+$/, "the campaign's numeric id"),
+  utm: z3.object({
+    campaign: z3.string().trim().min(1).max(255),
+    source: z3.string().trim().min(1).max(255),
+    medium: z3.string().trim().min(1).max(255)
+  }).strict()
+}).strict();
+var signupOfferHandleSchema = z3.string().regex(/^[a-z0-9][a-z0-9-]{1,39}$/, "2\u201340 lowercase letters, digits and dashes, e.g. welcome-10");
+var signupOfferSetSchema = z3.object({
+  /** What the store's staff see in front of each code, and the Store page's row. */
+  name: z3.string().trim().min(1).max(80),
+  value: discountValueSchema,
+  appliesTo: discountAppliesToSchema,
+  minimumSubtotal: shopifyDecimalSchema.optional(),
+  /** Each code's life, from the moment it is given. */
+  validForDays: z3.number().int().min(1).max(365),
+  /** The offer stops giving codes after this; no code outlives it. */
+  endsAt: isoDateTimeSchema.optional(),
+  /** How many codes the offer gives in all. */
+  maxCodes: z3.number().int().min(1).max(1e5).optional(),
+  /** The start of every code (WELCOME-7Q2M9XKD); default: the handle in capitals. */
+  codePrefix: z3.string().regex(/^[A-Z0-9]{2,12}$/, "2\u201312 capital letters or digits, e.g. WELCOME").optional(),
+  combinesWith: z3.object({
+    productDiscounts: z3.boolean().optional(),
+    orderDiscounts: z3.boolean().optional(),
+    shippingDiscounts: z3.boolean().optional()
+  }).strict().optional()
+}).strict();
+var emptySchema = z3.object({}).strict();
+var opFields = {
+  /** Optional caller-chosen ref for a create, so later ops in the batch can name it (`shopify_temp_…`). */
+  ref: z3.string().startsWith(SHOPIFY_TEMP_REF_PREFIX).max(80).optional()
+};
+var target = z3.string().trim().min(1).max(2048);
+var shopifyDraftOpInputSchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("shopify.product.update"), target, payload: productUpdateSchema, ...opFields }),
+  z3.object({ kind: z3.literal("shopify.variant.update"), target, payload: variantUpdateSchema, ...opFields }),
+  z3.object({ kind: z3.literal("shopify.metafield.set"), target, payload: metafieldSetSchema, ...opFields }),
+  z3.object({ kind: z3.literal("shopify.metafield.delete"), target, payload: metafieldDeleteSchema, ...opFields }),
+  z3.object({ kind: z3.literal("shopify.collection.create"), payload: collectionCreateSchema, ...opFields }),
+  z3.object({ kind: z3.literal("shopify.collection.publish"), target, payload: emptySchema.optional(), ...opFields }),
+  z3.object({ kind: z3.literal("shopify.collection.unpublish"), target, payload: emptySchema.optional(), ...opFields }),
+  z3.object({ kind: z3.literal("shopify.collection.update"), target, payload: collectionUpdateSchema, ...opFields }),
+  z3.object({ kind: z3.literal("shopify.collection.delete"), target, payload: emptySchema.optional(), ...opFields }),
+  z3.object({
+    kind: z3.literal("shopify.collection.addProducts"),
+    target,
+    payload: collectionProductsSchema,
+    ...opFields
+  }),
+  z3.object({
+    kind: z3.literal("shopify.collection.removeProducts"),
+    target,
+    payload: collectionProductsSchema,
+    ...opFields
+  }),
+  z3.object({ kind: z3.literal("shopify.discountCode.create"), payload: discountCreateSchema, ...opFields }),
+  z3.object({
+    kind: z3.literal("shopify.discountCode.deactivate"),
+    target,
+    payload: emptySchema.optional(),
+    ...opFields
+  }),
+  z3.object({ kind: z3.literal("shopify.discountCode.schedule"), target, payload: discountScheduleSchema, ...opFields }),
+  z3.object({ kind: z3.literal("shopify.urlRedirect.create"), payload: urlRedirectCreateSchema, ...opFields }),
+  z3.object({ kind: z3.literal("shopify.urlRedirect.delete"), target, payload: emptySchema.optional(), ...opFields }),
+  z3.object({ kind: z3.literal("shopify.marketingActivity.upsert"), payload: marketingUpsertSchema, ...opFields }),
+  z3.object({
+    kind: z3.literal("shopify.marketingActivity.delete"),
+    target,
+    payload: emptySchema.optional(),
+    ...opFields
+  }),
+  z3.object({ kind: z3.literal("shopify.webPixel.update"), payload: emptySchema.optional(), ...opFields }),
+  z3.object({
+    kind: z3.literal("shopify.signupOffer.set"),
+    target: signupOfferHandleSchema,
+    payload: signupOfferSetSchema,
+    ...opFields
+  }),
+  z3.object({
+    kind: z3.literal("shopify.signupOffer.end"),
+    target: signupOfferHandleSchema,
+    payload: emptySchema.optional(),
+    ...opFields
+  })
+]);
+var PAYLOAD_KEYS = new Map(
+  shopifyDraftOpInputSchema.options.map((option) => {
+    const payload = option.shape.payload;
+    const object = payload instanceof z3.ZodOptional ? payload.unwrap() : payload;
+    return [option.shape.kind.value, object instanceof z3.ZodObject ? Object.keys(object.shape) : []];
+  })
+);
+var askUserQuestionInputSchema = z3.object({
+  questions: z3.array(
+    z3.object({
+      question: z3.string(),
+      header: z3.string(),
+      multiSelect: z3.boolean(),
+      options: z3.array(z3.object({ label: z3.string(), description: z3.string() })).min(2)
+    })
+  ).min(1)
+});
+var shopifyNeedsApprovalSchema = z3.object({
+  /** Pass to AskUserQuestion exactly as given. */
+  askUserQuestion: askUserQuestionInputSchema,
+  /** The user already said no to (at least one of) these changes: don't ask again in this turn. */
+  declined: z3.boolean()
+});
+var shopifyVerificationSchema = z3.object({
+  status: z3.enum(["confirmed", "drifted", "unconfirmed"]),
+  checkedAt: z3.number(),
+  note: z3.string().optional()
+});
+var shopifyDraftOpResultSchema = z3.object({
+  status: z3.enum(["applied", "failed", "skipped"]),
+  createdId: z3.string().optional(),
+  error: z3.string().optional(),
+  note: z3.string().optional(),
+  skippedBecause: z3.string().optional(),
+  executedAt: z3.number().optional(),
+  pendingJob: z3.string().optional(),
+  verification: shopifyVerificationSchema.optional()
+});
+var stagedOpSchema = z3.object({
+  ref: z3.string(),
+  kind: shopifyDraftOpKindSchema,
+  summary: z3.string(),
+  warnings: z3.array(z3.string())
+});
+var shopifyDraftStageResponseSchema = z3.union([
+  z3.object({
+    staged: z3.literal(true),
+    count: z3.number(),
+    ops: z3.array(stagedOpSchema),
+    amended: z3.boolean().optional()
+  }),
+  z3.object({ staged: z3.literal(false), needsApproval: shopifyNeedsApprovalSchema })
+]);
+var SHOPIFY_DRAFT_BATCH_MAX = 100;
+var shopifyDraftStageRequestSchema = z3.object({ chatId: z3.string(), op: shopifyDraftOpInputSchema });
+var shopifyDraftStageBatchRequestSchema = z3.object({
+  chatId: z3.string(),
+  ops: z3.array(shopifyDraftOpInputSchema).min(1).max(SHOPIFY_DRAFT_BATCH_MAX)
+});
+var shopifyDraftAmendRequestSchema = z3.object({
+  chatId: z3.string(),
+  ref: z3.string(),
+  patch: z3.record(z3.string(), z3.unknown())
+});
+var shopifyDraftOpViewSchema = z3.object({
+  ref: z3.string(),
+  kind: shopifyDraftOpKindSchema,
+  entity: shopifyWriteEntitySchema,
+  target: z3.string().optional(),
+  targetLabel: z3.string().optional(),
+  summary: z3.string(),
+  money: z3.boolean(),
+  warnings: z3.array(z3.string()).optional(),
+  dependsOn: z3.array(z3.string()),
+  undoOf: z3.string().optional(),
+  stagedAt: z3.number(),
+  result: shopifyDraftOpResultSchema.optional()
+});
+var shopifyDraftListRequestSchema = z3.object({ chatId: z3.string() });
+var shopifyDraftListResponseSchema = z3.object({
+  status: z3.enum(["active", "publishing", "applied", "discarded", "none"]),
+  store: z3.string().optional(),
+  count: z3.number(),
+  ops: z3.array(shopifyDraftOpViewSchema),
+  publishError: z3.string().optional()
+});
+var shopifyDraftShowRequestSchema = z3.object({ chatId: z3.string(), ref: z3.string() });
+var shopifyDraftShowResponseSchema = z3.object({
+  op: shopifyDraftOpViewSchema.extend({ payload: z3.unknown().optional(), before: z3.unknown().optional() })
+});
+var shopifyDraftRemoveRequestSchema = z3.object({ chatId: z3.string(), ref: z3.string() });
+var shopifyDraftRemoveResponseSchema = z3.object({ removed: z3.array(z3.string()) });
+var shopifyDraftClearRequestSchema = z3.object({ chatId: z3.string() });
+var shopifyDraftClearResponseSchema = z3.object({ cleared: z3.number() });
+var shopifyChangeViewSchema = z3.object({
+  changeId: z3.string(),
+  when: z3.string(),
+  kind: shopifyDraftOpKindSchema,
+  summary: z3.string(),
+  status: z3.enum(["applied", "failed", "undone"]),
+  chatId: z3.string(),
+  undoable: z3.boolean(),
+  /** Why it can't be undone, when it can't. Whether the store still holds Baker's change is checked when undo is staged. */
+  notUndoableBecause: z3.string().optional()
+});
+var shopifyChangesRequestSchema = z3.object({
+  limit: z3.coerce.number().int().min(1).max(100).optional(),
+  chatId: z3.string().optional()
+});
+var shopifyChangesResponseSchema = z3.object({ changes: z3.array(shopifyChangeViewSchema) });
+var shopifyUndoRequestSchema = z3.object({
+  chatId: z3.string(),
+  changeIds: z3.array(z3.string().min(1)).min(1).max(SHOPIFY_DRAFT_BATCH_MAX)
+});
+
+// src/commands/shopify/refusal.ts
+var CONTINUE = "Keep going with the wider task: say which part you could not read, skip it, and finish everything else.";
+function shopifyRefusal(code, message) {
+  if (code !== "NOT_FOUND") return null;
+  if (message.includes(SHOPIFY_NOT_CONNECTED_MESSAGE)) {
+    return {
+      code: "NO_SHOPIFY_CONNECTION",
+      fix: {
+        action: "request_connection",
+        explanation: 'AGENT INSTRUCTION: no Shopify store is connected, and only the user can connect it. Call the `request_connection` tool with { platform: "shopify", reason } \u2014 reason in their words, e.g. "so I can use your real products and prices" \u2014 and they connect it inside the chat; then run this command again. ' + CONTINUE
+      }
+    };
+  }
+  if (message.includes(SHOPIFY_NOT_OFFERED_MESSAGE)) {
+    return {
+      code: "SHOPIFY_NOT_AVAILABLE",
+      fix: {
+        action: "continue_without",
+        explanation: "Do not call `request_connection` for Shopify and do not tell the user to connect it: a Shopify store cannot be connected on this Baker yet. Answer from the knowledge vault and the client's own website instead (`baker images extract <store url>` for product photos, `baker research fetch <url>` for a product page), say the product facts are unverified, and finish the rest of the task."
+      }
+    };
+  }
+  return null;
+}
+function storeChangeRefusal(code, message) {
+  if (code !== "FORBIDDEN" || !message.startsWith(SHOPIFY_PERMISSION_NEEDED_PREFIX)) return null;
+  return {
+    code: "SHOPIFY_PERMISSION_NEEDED",
+    fix: {
+      action: "request_connection",
+      explanation: 'AGENT INSTRUCTION: the store hasn\'t allowed Baker to make this kind of change yet, and only the user can. Call `request_connection` with { platform: "shopify", reason } \u2014 reason in their words, e.g. "so I can update your product titles". They allow it in Shopify; the card finishes when Shopify confirms. If its result lists something under cannotRead, that change is still not allowed: don\'t promise it. Then run this command again. Keep going with the rest of the task.'
+    }
+  };
+}
+function approvalRefusal(needsApproval) {
+  if (needsApproval.declined) {
+    return {
+      code: "NEEDS_USER_APPROVAL",
+      fix: {
+        action: "continue_without",
+        askUserQuestion: needsApproval.askUserQuestion,
+        explanation: "The user said no to this change. Don't stage it, don't ask again on your own, and don't find another way to make it; carry on with the rest of the task. Ask again only if the user asks for it again (they changed their mind): then call AskUserQuestion with `askUserQuestion` exactly as given, and if they choose \"Yes, make these changes\", run this same command again."
+      }
+    };
+  }
+  return {
+    code: "NEEDS_USER_APPROVAL",
+    fix: {
+      action: "ask_user",
+      askUserQuestion: needsApproval.askUserQuestion,
+      explanation: 'This changes money in the store, so the user says yes first. Call AskUserQuestion with `askUserQuestion` exactly as given (you may say a sentence before it, never change it). If the user chooses "Yes, make these changes", run this same command again. Do not stage it any other way.'
+    }
+  };
+}
+
+// src/commands/shopify/common.ts
+var PRODUCT_NOT_FOUND_HINT = "Find it with `baker shopify products --search <words>`. If `baker shopify store` shows products Baker couldn't read or products still coming in, it may be one of those \u2014 say so rather than that it doesn't exist.";
+function fail(err) {
+  if (err instanceof ApiError) {
+    const refusal = shopifyRefusal(err.code, err.message);
+    if (refusal) {
+      writeJson({ ok: false, error: { code: refusal.code, message: err.message, fix: refusal.fix } });
+      process.exit(1);
+    }
+    if (err.code === "NOT_FOUND" && err.message === SHOPIFY_BUYER_GONE_MESSAGE) {
+      writeJson({
+        ok: false,
+        error: { code: err.code, message: err.message },
+        hints: [
+          "Their store asked Baker to erase this buyer, or they were merged into another one: say the buyer is no longer in Baker, and never guess who they were."
+        ]
+      });
+      process.exit(1);
+    }
+    if (err.code === "NOT_FOUND" && err.message.startsWith(SHOPIFY_PRODUCT_NOT_FOUND_PREFIX)) {
+      writeJson({ ok: false, error: { code: err.code, message: err.message }, hints: [PRODUCT_NOT_FOUND_HINT] });
+      process.exit(1);
+    }
+  }
+  failApi(err);
+}
+function emit(data, meta, hints) {
+  writeJson({ ok: true, ...hints.length > 0 ? { hints } : {}, data, meta });
+}
+function params(entries) {
+  const out = {};
+  for (const [name, value] of Object.entries(entries)) {
+    if (value === void 0 || value === "" || value === false) continue;
+    out[name] = String(value);
+  }
+  return out;
+}
+var fullArg = {
+  type: "boolean",
+  description: "Everything Baker keeps, not just what answers the question",
+  required: false,
+  default: false
+};
+
+// src/commands/shopify/hints.ts
+var RECONNECT = 'Baker has lost access to this Shopify store, so these products may be out of date. Say so, and ask the user to reconnect with `request_connection` { platform: "shopify" } \u2014 the card offers Reconnect.';
+var OWN_STOREFRONT = "This store sells through its own storefront, not a Shopify online store: Baker links to its product pages once the website's address is set in Brain \u2192 Store (`buyUrlKind` says where each link goes); until then, link to the product pages on the client's own site, and ask the user for them if you don't know them.";
+function day(iso) {
+  return iso ? iso.slice(0, 10) : null;
+}
+function progress(store) {
+  const done = store.importProgress?.done;
+  const total = store.importProgress?.total;
+  if (done === void 0) return "";
+  return total === void 0 ? ` (${done} so far)` : ` (${done} of ${total})`;
+}
+function storeStateHints(store) {
+  const hints = [];
+  if (store.connection === "needs_reconnect") hints.push(RECONNECT);
+  if (store.connection === "disconnected") {
+    const last = day(store.lastActivity);
+    hints.push(
+      `This Shopify store is disconnected; these are its products as Baker last saw them${last ? ` (last activity ${last})` : ""}. Don't present prices or stock as current.`
+    );
+  }
+  if (store.catalog === "starting" || store.catalog === "importing") {
+    hints.push(
+      `Baker is still bringing in this store's products${progress(store)}; the list is incomplete \u2014 say so rather than concluding a product is missing.`
+    );
+  }
+  if (store.catalog === "failed") {
+    hints.push("Baker couldn't finish reading this store's products; the list may be incomplete.");
+  }
+  if (store.unreadable !== void 0) {
+    const count = store.unreadableCapped ? `${store.unreadable}+` : String(store.unreadable);
+    hints.push(
+      `Baker couldn't read ${count} of this store's products (it keeps retrying); they are missing from these answers \u2014 never tell the user a product doesn't exist or that the catalog is complete.`
+    );
+  }
+  if (store.checksFailing) {
+    hints.push("Baker couldn't check this store for changes lately; recent edits in Shopify may not show yet.");
+  }
+  if (store.storefront === "own") hints.push(OWN_STOREFRONT);
+  return hints;
+}
+function cleanAndReady(store) {
+  return store.catalog === "ready" && store.unreadable === void 0 && !store.checksFailing;
+}
+function productsHints(answer, options) {
+  const hints = [];
+  const notForSale = answer.products.filter((row) => row.availability === "not_for_sale").length;
+  const linkOnly = answer.products.filter((row) => row.availability === "link_only").length;
+  if (notForSale > 0) {
+    hints.push(
+      `${notForSale} of these can't be bought on the online store (draft, archived or hidden from it) \u2014 don't send ads or pages to them.`
+    );
+  }
+  if (linkOnly > 0) {
+    hints.push(
+      `${linkOnly} of these are only reachable by direct link \u2014 fine to link from an ad or a landing; they won't show in the store's search or collections.`
+    );
+  }
+  if (answer.nextCursor)
+    hints.push(`More products: rerun with \`--cursor ${answer.nextCursor}\` and the same filters.`);
+  if (answer.products.length === 0 && !answer.nextCursor) {
+    if (options.paged) hints.push("No more products: the earlier pages were the whole list.");
+    else if (options.filtered) hints.push("No products match; drop `--search`/`--stock`/`--collection`.");
+    else if (cleanAndReady(answer.store)) hints.push("The store has no products yet.");
+    else {
+      hints.push(
+        "Baker has no products for this store right now \u2014 see the notes above; don't tell the user the store is empty."
+      );
+    }
+  }
+  return hints;
+}
+function photoHints(product) {
+  const hints = [];
+  if (product.photos.length > 0) {
+    const ids = product.photos.map((photo) => photo.imageId).join(" ");
+    hints.push(
+      `Its photos are already in the image library. For a landing: \`mkdir -p src/pages/<page>/_images && baker images download ${ids} --out src/pages/<page>/_images/\`; for a creative, pass the imageIds as references. Never use a cdn.shopify.com link \u2014 pages refuse it.`
+    );
+  }
+  if (product.photosNotBrought > 0) {
+    hints.push(
+      `${product.photosNotBrought} more photos stay in Shopify (Baker keeps up to 10 per product); use the ones listed.`
+    );
+  }
+  if (product.photosAdding > 0) {
+    hints.push(`${product.photosAdding} photos are still being added; run this again in a minute if you need them.`);
+  }
+  return hints;
+}
+function stockHintsFor(product) {
+  const hints = [];
+  if (product.stock.optionsOut > 0) {
+    const names = product.outOptions.map((option) => option.title).join(", ");
+    hints.push(
+      product.stock.state === "out_of_stock" ? "Every option is out of stock \u2014 don't promote it; `baker shopify stock` lists every product like this." : `Options out of stock: ${names} \u2014 don't promote them; \`baker shopify stock\` lists every product like this.`
+    );
+  }
+  if (product.outOptionsMore) {
+    hints.push(
+      `${product.outOptionsMore} more options are out of stock: \`baker shopify product ${product.productId} --out-of-stock\` (then \`--variants-cursor\` for the next page).`
+    );
+  }
+  if (product.variantsNextCursor) {
+    hints.push(`More options: rerun with \`--variants-cursor ${product.variantsNextCursor}\`.`);
+  }
+  return hints;
+}
+var BUY_NOTES = {
+  password_protected: "The store asks for a password before anyone can see it: a shopper following a buy link meets it first \u2014 tell the user before sending traffic.",
+  subscription_optional: "It can also be bought by subscription: on a landing `<ShopifyProduct>` offers the plans; a `buyUrl` elsewhere adds it once.",
+  own_storefront: "The store sells through its own website: `buyUrlKind` says where each link goes \u2014 its product page, or its cart page once its developers confirm it in Brain \u2192 Store.",
+  details_pending: "Baker hasn't read this product's details yet (subscriptions among them): its buy links may change.",
+  subscription_only: "It's sold only by subscription: on a landing `<ShopifyProduct>` offers the plans; a `buyUrl` elsewhere is its product page, where the shopper picks one."
+};
+function buyHints(product) {
+  const hints = [];
+  if (product.variants.some((variant) => variant.buyUrl)) {
+    hints.push(
+      `On a landing, place \`<ShopifyProduct product="${product.handle}" />\` (and \`<ShopifyBuyButton product="${product.handle}">\` for a second button): it shows the options, price and stock, and its button hands the shopper to the store. Never put a \`buyUrl\` on a landing yourself, and never build an option picker. See /landing \`.claude/skills/landing/references/verticals/ecommerce.md\`.`,
+      `\`buyUrl\` is for links outside a landing \u2014 an ad, an email, a message: one per option; never \`storeUrl\` (a page to look at), never a Shopify link built yourself (it follows the store's setting: ${product.buyDestination.replace("_", " ")}; \`--quantity <n>\` sets how many).`
+    );
+  }
+  const notes = new Set(product.variants.flatMap((variant) => variant.notes ?? []));
+  for (const note of notes) hints.push(BUY_NOTES[note]);
+  return hints;
+}
+function contentHints(product) {
+  const hints = [];
+  const [video] = product.videos;
+  if (video) {
+    hints.push(
+      `Its videos are already in the video library: place one with \`<Video playbackId="${video.playbackId}" />\` \u2014 never a Shopify video link.`
+    );
+  }
+  if (product.videosNotBrought > 0) {
+    hints.push(
+      `${product.videosNotBrought} more videos stay in Shopify (Baker keeps up to 5 per product); use the ones listed.`
+    );
+  }
+  if (product.videosAdding > 0) hints.push(`${product.videosAdding} videos are still being added.`);
+  if (product.contentSummary && !product.content) {
+    hints.push(
+      "For a landing or an ad, read the whole of it with `--content` (formatted description, custom fields, subscriptions, translations)."
+    );
+  }
+  const truncated = product.content?.fields.find((field) => field.truncated);
+  if (truncated) {
+    const option = truncated.variantId ? ` --variant ${truncated.variantId}` : "";
+    hints.push(`Some fields are shown in part: read one whole with \`--field ${truncated.key}${option}\`.`);
+  }
+  if (product.content?.unreadable?.length || product.content?.fields.some((field) => field.unreadable)) {
+    hints.push(
+      "Some content isn't readable yet: ask the user to open Baker in their Shopify admin and accept the new permissions."
+    );
+  }
+  return hints;
+}
+function productHints(product, store) {
+  const hints = [...photoHints(product), ...stockHintsFor(product), ...buyHints(product), ...contentHints(product)];
+  if (product.availability === "not_for_sale") {
+    hints.push(
+      `Can't be bought on the online store (${(product.status ?? "hidden").toLowerCase()}): a page or ad linking to it sends people to a page they can't buy from.`
+    );
+  }
+  if (product.availability === "link_only") {
+    hints.push(
+      `This product is only reachable by direct link${product.storeUrl ? ` (${product.storeUrl})` : ""} \u2014 fine to link from an ad or a landing; it won't show in the store's search or collections.`
+    );
+  }
+  if (product.compareAt) {
+    hints.push(`On sale: was ${product.compareAt}, now ${product.price}.`);
+  }
+  if (product.pricesByCountry) {
+    hints.push(
+      "Prices differ by country \u2014 quote the country's price from pricesByCountry, never convert the home price."
+    );
+  }
+  if (store.storefront === "own" && !product.storeUrl) {
+    hints.push("Ask the user for this product's page on their own site before linking to it.");
+  }
+  return hints;
+}
+function stockHints(answer, limit2) {
+  const hints = [];
+  const any = answer.outOfStock.length > 0 || answer.partlyOut.length > 0;
+  const unfinished = answer.more.outOfStock || answer.more.partlyOut;
+  const pageThrough = "page through with `baker shopify products --stock out_of_stock` / `--stock partly_out` (and the same `--collection`)";
+  if (any) {
+    hints.push(
+      "Before promoting these, check which ads and pages point at them; pausing or swapping them is a staged change."
+    );
+  } else if (!unfinished) hints.push("Nothing is out of stock.");
+  if (unfinished) {
+    const full = answer.more.outOfStock && answer.outOfStock.length >= limit2 || answer.more.partlyOut && answer.partlyOut.length >= limit2;
+    hints.push(
+      full ? `More than ${limit2} products in a list; raise \`--limit\` (up to 200) or ${pageThrough}.` : `Baker didn't check every product in one go, so these lists may be missing some \u2014 don't say nothing else is out of stock; ${pageThrough}.`
+    );
+  }
+  const big = answer.partlyOut.find((row) => row.outOptionsMore);
+  if (big) {
+    hints.push(
+      `Not every out-of-stock option is listed: \`baker shopify product ${big.productId} --out-of-stock\` lists them all.`
+    );
+  }
+  return hints;
+}
+function storeHints(summary) {
+  const hints = ["Share the Products page link (productsUrl) when the user wants to browse the catalog."];
+  if (summary.unreadable?.length) {
+    hints.push(
+      "Some of the store's content isn't readable yet: ask the user to open Baker in their Shopify admin and accept the new permissions."
+    );
+  }
+  if (summary.passwordProtected) {
+    hints.push(
+      "The store asks for a password before anyone can see it: shoppers from a landing or an ad meet it first."
+    );
+  }
+  if (summary.capped) {
+    const atCeiling = [
+      summary.outOfStock >= SHOPIFY_STOCK_COUNT_CAP ? `${SHOPIFY_STOCK_COUNT_CAP} or more products out of stock` : null,
+      summary.partlyOut >= SHOPIFY_STOCK_COUNT_CAP ? `${SHOPIFY_STOCK_COUNT_CAP} or more products partly out` : null,
+      summary.collections >= SHOPIFY_COLLECTION_COUNT_CAP ? `${SHOPIFY_COLLECTION_COUNT_CAP} or more collections` : null
+    ].filter((count) => count !== null);
+    hints.push(
+      `Some counts stopped at Baker's ceiling: say ${atCeiling.join(", ")} \u2014 never the number as exact. \`baker shopify stock\` and \`baker shopify products --stock out_of_stock\` page through them.`
+    );
+  }
+  return hints;
+}
+function timingHints(answer) {
+  const peak = [...answer.rows].sort((a, b) => b.orders - a.orders)[0];
+  if (!peak || peak.orders === 0) return [];
+  const zone = answer.window.timezone ? `, ${answer.window.timezone}` : "";
+  const when = answer.by === "hour" ? `at ${peak.label}` : answer.by === "month_of_year" ? `in ${peak.label}` : `on ${peak.label}`;
+  return [`Most orders are placed ${when} (store time${zone}): weight budgets and sends towards it.`];
+}
+function salesHints(answer) {
+  const hints = [];
+  if (answer.ordersUnreadable) {
+    hints.push(
+      "Baker can't read this store's orders right now, so these sales may be incomplete. Ask the user to reconnect the store with `request_connection` { platform: \"shopify\" }."
+    );
+  }
+  if (answer.history === "importing") {
+    hints.push(
+      "Baker is still bringing in this store's past orders; earlier periods are incomplete \u2014 say so rather than reporting a drop."
+    );
+  }
+  if (answer.totals.orders === 0) {
+    hints.push("No orders were paid in this period.");
+    return hints;
+  }
+  if (answer.by === "weekday" || answer.by === "hour" || answer.by === "month_of_year") {
+    return [...hints, ...timingHints(answer)];
+  }
+  const notBaker = ["meta", "google"].filter((family) => answer.salesReporting[family] !== "baker");
+  if (notBaker.length > 0) {
+    const names = notBaker.map((family) => family === "meta" ? "Meta" : "Google").join(" and ");
+    hints.push(
+      `Baker only reports these sales; it does not send them to ${names}. A manager chooses in Brain \u2192 Store whether Baker sends them (where Shopify's own channel already reports sales, its purchase tracking has to be turned off first). Never set up a purchase send yourself.`
+    );
+  }
+  const unattributed = answer.rows.filter((row) => row.credit === "unattributed").reduce((total, row) => total + row.net, 0);
+  if ((answer.by === "campaign" || answer.by === "landing") && answer.totals.net > 0 && unattributed / answer.totals.net > 0.5) {
+    hints.push(
+      "Most of these sales came from no campaign Baker found: buyers who came straight to the store, or from links without campaign tags. Say so rather than crediting them to a campaign; links with UTM tags and Baker landings make the next ones traceable."
+    );
+  }
+  const leading = answer.by === "landing" ? answer.rows.find((row) => row.credit === "landing") : void 0;
+  if (leading && leading.net > 0) {
+    hints.push(
+      `"${leading.label}" brought the most sales of the Baker pages (${answer.currency ?? ""} ${leading.net}). It is the page to learn from before building the next one.`
+    );
+  }
+  return hints;
+}
+
+// src/commands/shopify/buyers.ts
+var PERIOD_NOTE = "Orders placed in the period, in the store's own time, with what was refunded on them since (Shopify's own reports date a refund when it happens instead, so a short period can differ by the refunds that cross its edges).";
+var periodArgs = {
+  days: { type: "number", description: "The last N days, 1-3650 (default 365)", required: false },
+  all: { type: "boolean", description: "Every order the store has", required: false, default: false },
+  country: {
+    type: "string",
+    description: "Only orders to this country: its two-letter code, like DE",
+    required: false
+  }
+};
+var periodFlags = {
+  days: { type: "string", description: "The last N days, 1-3650 (default 365)", required: false },
+  all: { type: "boolean", description: "Every order the store has", required: false, default: false },
+  country: { type: "string", description: "Only orders to this country (two-letter code, like DE)", required: false }
+};
+function split(answer) {
+  const { store, window, history, basis, ...data } = answer;
+  return { data, meta: { store, window, history, basis } };
+}
+registerSchema({
+  command: "shopify.buyers",
+  description: `Start here for 'who buys from us', 'how many come back' and 'which campaign brings the best customers': the store's buyers in the period \u2014 how many, how many were new, repeat rate, days to a second order, guest orders \u2014 their segments (best, loyal, at risk, new, one-time, by this store's own rhythm) and the top buyers as numbered customers with their country, lifetime spend and the channel of their first order. --by campaign|channel adds lifetime value per acquisition campaign or channel (Baker keeps no ad spend: read it with the ads commands for the same dates). ${PERIOD_NOTE} A buyer is a Shopify customer: guest orders count in money, never as buyers.`,
+  args: {
+    ...periodArgs,
+    segment: {
+      type: "string",
+      description: "Only one segment's buyers: best | loyal | at_risk | new | one_time",
+      required: false,
+      enum: ["best", "loyal", "at_risk", "new", "one_time"]
+    },
+    by: {
+      type: "string",
+      description: "Lifetime value by the campaign or channel of each buyer's first order",
+      required: false,
+      enum: ["campaign", "channel"]
+    },
+    channel: {
+      type: "string",
+      description: "Only buyers who first came through this channel (a key from --by channel)",
+      required: false
+    },
+    sort: {
+      type: "string",
+      description: "net (lifetime spend, default) | orders | recent (last order) | first (first order)",
+      required: false,
+      enum: ["net", "orders", "recent", "first"]
+    },
+    limit: { type: "number", description: "Buyers listed, 1-100 (default 10)", required: false },
+    offset: { type: "number", description: "Skip this many buyers (paging)", required: false },
+    full: {
+      ...fullArg,
+      description: "Add each buyer's gross, refunds, orders with a discount, days between orders and first-order campaign"
+    }
+  }
+});
+var buyersCommand = defineCommand({
+  meta: {
+    name: "buyers",
+    description: "Who buys: buyers, new and returning, repeat rate, segments and the top buyers. Start here: baker shopify buyers --days 90 --by channel"
+  },
+  args: {
+    ...periodFlags,
+    segment: { type: "string", description: "best | loyal | at_risk | new | one_time", required: false },
+    by: { type: "string", description: "campaign | channel", required: false },
+    channel: { type: "string", description: "A channel key from --by channel", required: false },
+    sort: { type: "string", description: "net | orders | recent | first", required: false },
+    limit: { type: "string", description: "Buyers listed, 1-100", required: false },
+    offset: { type: "string", description: "Skip this many buyers", required: false },
+    full: { type: "boolean", description: "Add each buyer's detail", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet(
+        "/api/shopify/buyers",
+        params({
+          days: args.days,
+          all: args.all,
+          country: args.country,
+          segment: args.segment,
+          by: args.by,
+          channel: args.channel,
+          sort: args.sort,
+          limit: args.limit,
+          offset: args.offset,
+          full: args.full
+        })
+      );
+      const { data, meta } = split(answer);
+      emit(data, meta, [...storeStateHints(answer.store), ...buyersHints(answer)]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+registerSchema({
+  command: "shopify.buyer",
+  description: "One buyer by their number (1042, #1042 or 'Customer #1042'): where they are, how many orders and how much they spent net of refunds, average order, days between orders, first and last order, discount use, segment and how they first came \u2014 then every order (date in the store's time, products and quantities, net, refunded, discount codes, city), newest first, and what they bought. Never a name or an email. A buyer their store asked Baker to erase, or merged into another, answers 'This buyer is no longer in Baker'.",
+  args: {
+    number: { type: "positional", description: "The buyer's number: 1042, #1042 or 'Customer #1042'", required: true },
+    full: { ...fullArg, description: "Add each order's id, lines with their amounts, refunded lines and campaign" }
+  }
+});
+var buyerCommand = defineCommand({
+  meta: {
+    name: "buyer",
+    description: "One buyer's history by number. Example: baker shopify buyer 1042"
+  },
+  args: {
+    number: { type: "positional", description: "1042, #1042 or 'Customer #1042'", required: true },
+    full: { type: "boolean", description: "Add ids, lines and campaigns", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet(
+        "/api/shopify/buyer",
+        params({ number: args.number, full: args.full })
+      );
+      const { data, meta } = split(answer);
+      emit(data, meta, [...storeStateHints(answer.store), ...buyerHistoryHints(answer.history, answer.basis)]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+registerSchema({
+  command: "shopify.countries",
+  description: `Start here for 'where do our buyers come from' and 'which countries should we push': orders, buyers, new buyers, net, average order, share and growth against the period before, by country \u2014 or by region inside --country (straight by city for a country whose addresses carry no region, like Germany), or by city inside --country and --region \u2014 with the currency buyers paid in. Orders whose address Baker could not read are 'Unknown' ('No region given' / 'No city given' inside a country), always shown; the rows, that row and 'Other' add up to the total. --product narrows to the orders holding one product, with that product's money. ${PERIOD_NOTE}`,
+  args: {
+    ...periodArgs,
+    region: { type: "string", description: "Inside --country, one region (code or name): its cities", required: false },
+    product: { type: "string", description: "Only orders holding this product: its id or handle", required: false },
+    limit: { type: "number", description: "Places listed, 1-100 (default 25; the rest are 'Other')", required: false },
+    full: { ...fullArg, description: "Add the period before's net and orders per place" }
+  }
+});
+var countriesCommand = defineCommand({
+  meta: {
+    name: "countries",
+    description: "Where buyers are: orders, buyers and net by country, region or city, with growth. Start here: baker shopify countries --days 90"
+  },
+  args: {
+    ...periodFlags,
+    region: { type: "string", description: "A region inside --country", required: false },
+    product: { type: "string", description: "A product's id or handle", required: false },
+    limit: { type: "string", description: "Places listed, 1-100", required: false },
+    full: { type: "boolean", description: "Add the period before", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet(
+        "/api/shopify/countries",
+        params({
+          days: args.days,
+          all: args.all,
+          country: args.country,
+          region: args.region,
+          product: args.product,
+          limit: args.limit,
+          full: args.full
+        })
+      );
+      const { data, meta } = split(answer);
+      emit(data, meta, [...storeStateHints(answer.store), ...countriesHints(answer)]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+registerSchema({
+  command: "shopify.bestSellers",
+  description: `Start here for 'what sells best' and 'which product should we lead with': best sellers by units ordered (before anything came back) beside refunded units, orders, buyers, revenue (the lines' price after discounts, before tax and shipping), refunds, refund rate and growth. --view variants (one product's options, with --product), trend (top products by month), together (products bought in one order), repeat (first buys whose buyers came back most) or momentum (products selling 30% or more below the period before). ${PERIOD_NOTE} For the catalog itself use \`baker shopify products\`.`,
+  args: {
+    ...periodArgs,
+    view: {
+      type: "string",
+      description: "products (default) | variants | trend | together | repeat | momentum",
+      required: false,
+      enum: ["products", "variants", "trend", "together", "repeat", "momentum"]
+    },
+    sort: {
+      type: "string",
+      description: "units (default) | revenue | orders",
+      required: false,
+      enum: ["units", "revenue", "orders"]
+    },
+    product: { type: "string", description: "One product (id or handle): its variants or its trend", required: false },
+    limit: { type: "number", description: "Rows, 1-100 (default 10; 5 products for trend)", required: false },
+    full: { ...fullArg, description: "Add product and variant ids and the period before" }
+  }
+});
+var bestSellersCommand = defineCommand({
+  meta: {
+    name: "best-sellers",
+    description: "What sells: best sellers, variants, trend, bought together, repeat leaders, losing momentum. Start here: baker shopify best-sellers --days 90"
+  },
+  args: {
+    ...periodFlags,
+    view: {
+      type: "string",
+      description: "products | variants | trend | together | repeat | momentum",
+      required: false
+    },
+    sort: { type: "string", description: "units | revenue | orders", required: false },
+    product: { type: "string", description: "A product's id or handle", required: false },
+    limit: { type: "string", description: "Rows, 1-100", required: false },
+    full: { type: "boolean", description: "Add ids and the period before", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet(
+        "/api/shopify/best-sellers",
+        params({
+          days: args.days,
+          all: args.all,
+          country: args.country,
+          view: args.view,
+          sort: args.sort,
+          product: args.product,
+          limit: args.limit,
+          full: args.full
+        })
+      );
+      const { data, meta } = split(answer);
+      emit(data, meta, [...storeStateHints(answer.store), ...bestSellersHints(answer)]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+registerSchema({
+  command: "shopify.cohorts",
+  description: "Buyers grouped by the month of their first order (the last --months, default 12): how many, the share who ordered again 1, 2, 3, 6 and 12 months later, and what they spent per buyer by month 12. Months not reached yet are null. Use it for 'are buyers coming back more than they used to' and lifetime value over time.",
+  args: {
+    months: { type: "number", description: "Cohorts, the last 3-36 months (default 12)", required: false },
+    country: { type: "string", description: "Only orders to this country (two-letter code)", required: false },
+    full: {
+      ...fullArg,
+      description: "Add every month of every cohort: active buyers, orders, net, cumulative net per buyer"
+    }
+  }
+});
+var cohortsCommand = defineCommand({
+  meta: {
+    name: "cohorts",
+    description: "Buyers by first-order month: who came back and what they spent. Example: baker shopify cohorts --months 12"
+  },
+  args: {
+    months: { type: "string", description: "The last 3-36 months", required: false },
+    country: { type: "string", description: "A two-letter country code", required: false },
+    full: { type: "boolean", description: "Every month of every cohort", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet(
+        "/api/shopify/cohorts",
+        params({ months: args.months, country: args.country, full: args.full })
+      );
+      const { data, meta } = split(answer);
+      emit(data, meta, [...storeStateHints(answer.store), ...cohortsHints(answer)]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+registerSchema({
+  command: "shopify.segments",
+  description: "Every buyer at the period's end by segment \u2014 best buyers, loyal, at risk, new and one-time \u2014 with how many, their share, net, average orders, days since their last order, the countries they are in and the products their first orders held. Each segment's rule is given in words with this store's own numbers (its typical gap between orders and the spend of its top fifth). Start here for 'who are our best customers' and 'who should we win back'.",
+  args: {
+    ...periodArgs,
+    full: { ...fullArg, description: "Add the first products' ids" }
+  }
+});
+var segmentsCommand = defineCommand({
+  meta: {
+    name: "segments",
+    description: "Buyers by segment: best, loyal, at risk, new, one-time. Example: baker shopify segments"
+  },
+  args: {
+    ...periodFlags,
+    full: { type: "boolean", description: "Add product ids", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet(
+        "/api/shopify/segments",
+        params({ days: args.days, all: args.all, country: args.country, full: args.full })
+      );
+      const { data, meta } = split(answer);
+      emit(data, meta, [...storeStateHints(answer.store), ...segmentsHints(answer)]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+
+// src/commands/shopify/change.ts
+import { defineCommand as defineCommand3 } from "citty";
+
+// src/commands/shopify/writeCommon.ts
+import { defineCommand as defineCommand2 } from "citty";
+
+// src/commands/shopify/writeHints.ts
+var STAGED = "Staged \u2014 nothing changes in the store until the user publishes the chat. Review: `baker shopify draft list`. Say the change is ready and happens when they publish, never that it is done.";
+var WARNINGS = "Read the warnings above before telling the user this is ready.";
+var DISCOUNT = "The code works only after the chat is published; don't announce it as live or share it as working yet.";
+var EMPTY_COLLECTION = "The new collection has no products yet: add them with `baker shopify change collection add <collection> <product\u2026>`.";
+var COLLECTION_DELETE = "Its address stops working when it is deleted: keep old links alive with `baker shopify change redirect create --from /collections/<handle> --to <page>` (ask the user where they should land).";
+function repointedRedirects(ops) {
+  const removed = ops.flatMap(
+    (op) => op.kind === "shopify.urlRedirect.delete" && op.ref.startsWith("urlRedirect:") ? [op.ref.slice("urlRedirect:".length)] : []
+  );
+  return removed.flatMap((path2) => {
+    const made = ops.find(
+      (op) => op.kind === "shopify.urlRedirect.create" && op.summary.startsWith(`Redirect ${path2} to `)
+    );
+    if (!made) return [];
+    const to = made.summary.slice(`Redirect ${path2} to `.length);
+    return [
+      `${path2} still redirects after publish, now to ${to}: tell the user the old link goes there, not that its redirect is removed.`
+    ];
+  });
+}
+function stageHints(data) {
+  if (!data.staged) return [];
+  const hints = [STAGED, ...repointedRedirects(data.ops)];
+  if (data.ops.some((op) => op.warnings.length > 0)) hints.push(WARNINGS);
+  if (data.ops.some((op) => op.kind === "shopify.discountCode.create")) hints.push(DISCOUNT);
+  if (data.ops.some((op) => op.kind === "shopify.collection.delete")) hints.push(COLLECTION_DELETE);
+  if (data.ops.some(
+    (op) => op.kind === "shopify.collection.create" && op.warnings.some((warning) => /no products/.test(warning))
+  )) {
+    hints.push(EMPTY_COLLECTION);
+  }
+  return hints;
+}
+function changesHints(data) {
+  if (data.changes.length === 0) return ["Baker hasn't changed this store yet."];
+  return data.changes.some((change) => change.undoable) ? ["Undo one with `baker shopify undo <changeId>` (staged like any change, applied when the user publishes)."] : [];
+}
+function auditHints(data) {
+  const hints = [];
+  for (const check of data.checks) {
+    if (check.fix?.kind === "staged") hints.push(`Stage the fix for "${check.title}": \`${check.fix.command}\`.`);
+  }
+  for (const check of data.checks) {
+    if (check.fix?.kind === "merchant") {
+      hints.push(
+        `Only the merchant can fix "${check.title}": ${check.fix.task}. Make it a Task with \`baker actions create\`${check.fix.link ? " and include the link" : ""}.`
+      );
+    }
+  }
+  for (const check of data.checks) {
+    if (check.fix?.kind === "decision") hints.push(`A person decides "${check.title}": ${check.fix.where}.`);
+  }
+  return hints;
+}
+
+// src/commands/shopify/writeCommon.ts
+function failChange(err) {
+  if (err instanceof ApiError) {
+    const refusal = storeChangeRefusal(err.code, err.message);
+    if (refusal) {
+      writeJson({ ok: false, error: { code: refusal.code, message: err.message, fix: refusal.fix } });
+      process.exit(1);
+    }
+  }
+  fail(err);
+}
+function emitStage(data) {
+  if (!data.staged) {
+    const refusal = approvalRefusal(data.needsApproval);
+    writeJson({
+      ok: false,
+      error: {
+        code: refusal.code,
+        message: data.needsApproval.declined ? "The user said no to this change in the chat." : "This changes money in the store: the user has to say yes to it in the chat first.",
+        fix: refusal.fix
+      }
+    });
+    process.exit(1);
+  }
+  writeJson({ ok: true, hints: stageHints(data), data });
+}
+async function stage(ops) {
+  const chatId = requireChatId();
+  try {
+    const [only] = ops;
+    const data = ops.length === 1 && only ? await apiPost("/api/shopify/draft/stage", { chatId, op: only }) : await apiPost("/api/shopify/draft/stage-batch", { chatId, ops });
+    emitStage(data);
+  } catch (err) {
+    failChange(err);
+  }
+}
+function list(value) {
+  if (typeof value !== "string" || value.trim() === "") return void 0;
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function defined(entries) {
+  return Object.fromEntries(Object.entries(entries).filter(([, value]) => value !== void 0 && value !== ""));
+}
+function payloadsFrom(args) {
+  if (typeof args.json !== "string" && typeof args.file !== "string") return null;
+  return loadJsonPayloads(args);
+}
+var JSON_ARGS = {
+  json: {
+    type: "string",
+    description: 'The change as inline JSON: a payload for the target given (e.g. {"addTags":["summer"]}), or an array of {"kind","target","payload"} items to stage together in one store read',
+    required: false
+  },
+  file: { type: "string", description: "A JSON file holding the same", required: false }
+};
+function leaf(schemaName, meta, args, run) {
+  registerSchema({
+    command: schemaName,
+    description: meta.description,
+    args: Object.fromEntries(
+      Object.entries(args).map(([name, arg]) => [
+        name,
+        {
+          type: String(arg.type ?? "string"),
+          description: String(arg.description ?? ""),
+          required: arg.required === true
+        }
+      ])
+    )
+  });
+  return defineCommand2({ meta, args, run: async ({ args: parsed }) => await run(parsed) });
+}
+
+// src/commands/shopify/change.ts
+var TARGET = (what) => ({ type: "positional", description: what, required: false });
+function positionals(args) {
+  return Array.isArray(args._) ? args._.filter((value) => typeof value === "string") : [];
+}
+function target2(args, what) {
+  const [first] = positionals(args);
+  if (!first) failValidation(`pass the ${what} as the first argument`);
+  return first;
+}
+async function stageFor(kind, args, flags, targetOf) {
+  const payloads = payloadsFrom(args);
+  if (payloads) {
+    await stage(
+      payloads.map(
+        (payload2) => "kind" in payload2 ? payload2 : { kind, ...targetOf ? { target: targetOf() } : {}, payload: payload2 }
+      )
+    );
+    return;
+  }
+  const payload = flags();
+  if (Object.keys(payload).length === 0)
+    failValidation("name at least one thing to change (see `baker schema` for the flags)");
+  await stage([{ kind, ...targetOf ? { target: targetOf() } : {}, payload }]);
+}
+var productUpdate = leaf(
+  "shopify.change.product.update",
+  {
+    name: "update",
+    description: `Start here to change a product's title, description, SEO, tags or type. Example: baker shopify change product update the-snowboard --title "The Snowboard" --seo-title "\u2026" --add-tags summer. Tags: --tags replaces the whole list, --add-tags/--remove-tags edit it. Descriptions are HTML without scripts or frames. Many products in one call: --json '[{"kind":"shopify.product.update","target":"<handle>","payload":{"addTags":["summer"]}}, \u2026]' \u2014 payload keys: title, descriptionHtml, seo {title, description}, tags | addTags | removeTags, productType.`
+  },
+  {
+    product: TARGET("Product id, handle or link"),
+    title: { type: "string", description: "New title", required: false },
+    description: { type: "string", description: "New description, as HTML (no scripts or frames)", required: false },
+    "seo-title": { type: "string", description: "Title shown in search results", required: false },
+    "seo-description": { type: "string", description: "Description shown in search results", required: false },
+    tags: { type: "string", description: "The whole tag list, comma separated (replaces it)", required: false },
+    "add-tags": { type: "string", description: "Tags to add, comma separated", required: false },
+    "remove-tags": { type: "string", description: "Tags to remove, comma separated", required: false },
+    type: { type: "string", description: "Product type", required: false },
+    ...JSON_ARGS
+  },
+  async (args) => await stageFor(
+    "shopify.product.update",
+    args,
+    () => defined({
+      title: args.title,
+      descriptionHtml: args.description,
+      seo: args["seo-title"] !== void 0 || args["seo-description"] !== void 0 ? defined({ title: args["seo-title"], description: args["seo-description"] }) : void 0,
+      tags: list(args.tags),
+      addTags: list(args["add-tags"]),
+      removeTags: list(args["remove-tags"]),
+      productType: args.type
+    }),
+    positionals(args).length > 0 ? () => target2(args, "product") : void 0
+  )
+);
+var WEIGHT_UNITS = {
+  g: "GRAMS",
+  gram: "GRAMS",
+  grams: "GRAMS",
+  kg: "KILOGRAMS",
+  kgs: "KILOGRAMS",
+  kilogram: "KILOGRAMS",
+  kilograms: "KILOGRAMS",
+  oz: "OUNCES",
+  ounce: "OUNCES",
+  ounces: "OUNCES",
+  lb: "POUNDS",
+  lbs: "POUNDS",
+  pound: "POUNDS",
+  pounds: "POUNDS"
+};
+function weightOf(value, unit) {
+  if (value === void 0) return void 0;
+  const named = typeof unit === "string" ? unit.trim() : "";
+  return {
+    value: Number(value),
+    unit: named ? WEIGHT_UNITS[named.toLowerCase()] ?? named.toUpperCase() : "KILOGRAMS"
+  };
+}
+var variantUpdate = leaf(
+  "shopify.change.variant.update",
+  {
+    name: "update",
+    description: "Change one option (variant) of a product: SKU, barcode (GTIN), weight \u2014 and its price or sale price, which the user must approve in the chat first (the command hands you the question). Take the option's id from `baker shopify product <product>` (variantId). Example: baker shopify change variant update 456 --sku SNOW-L --barcode 4006381333931 --weight 1.5 --weight-unit kg. --sale-price none clears it."
+  },
+  {
+    variant: TARGET("The option's id (variantId from baker shopify product)"),
+    sku: { type: "string", description: "SKU", required: false },
+    barcode: { type: "string", description: "Barcode / GTIN (8, 12, 13 or 14 digits)", required: false },
+    weight: { type: "string", description: "Weight value", required: false },
+    "weight-unit": {
+      type: "string",
+      description: "kg | g | lb | oz (default kg)",
+      required: false
+    },
+    price: {
+      type: "string",
+      description: `Price as a decimal, e.g. "649.95" (needs the user's yes)`,
+      required: false
+    },
+    "sale-price": {
+      type: "string",
+      description: `Compare-at price, or "none" to clear it (needs the user's yes)`,
+      required: false
+    },
+    ...JSON_ARGS
+  },
+  async (args) => await stageFor(
+    "shopify.variant.update",
+    args,
+    () => defined({
+      sku: args.sku,
+      barcode: args.barcode,
+      weight: weightOf(args.weight, args["weight-unit"]),
+      price: args.price,
+      compareAtPrice: args["sale-price"] === "none" ? null : args["sale-price"]
+    }),
+    positionals(args).length > 0 ? () => target2(args, "option id") : void 0
+  )
+);
+var fieldSet = leaf(
+  "shopify.change.field.set",
+  {
+    name: "set",
+    description: 'Set a custom field (metafield) on a product, an option or a collection. The owner is product:<ref>, variant:<id>, collection:<ref> or a collection staged in this chat (its shopify_temp_ ref); a bare reference is a product. If the store defines the field, send its type. Example: baker shopify change field set product:the-snowboard --namespace custom --key care --type single_line_text_field --value "Wash cold".'
+  },
+  {
+    owner: TARGET("product:<ref>, variant:<id> or collection:<ref>"),
+    namespace: { type: "string", description: "Namespace, e.g. custom", required: false },
+    key: { type: "string", description: "Key, e.g. care", required: false },
+    type: {
+      type: "string",
+      description: "Shopify's type, e.g. single_line_text_field, rich_text_field, json",
+      required: false
+    },
+    value: { type: "string", description: "The value, as Shopify takes it for that type", required: false },
+    ...JSON_ARGS
+  },
+  async (args) => await stageFor(
+    "shopify.metafield.set",
+    args,
+    () => defined({ namespace: args.namespace, key: args.key, type: args.type, value: args.value }),
+    () => target2(args, "owner")
+  )
+);
+var fieldRemove = leaf(
+  "shopify.change.field.remove",
+  {
+    name: "remove",
+    description: "Remove a custom field from a product, an option or a collection. Example: baker shopify change field remove product:the-snowboard custom.care"
+  },
+  {
+    owner: TARGET("product:<ref>, variant:<id> or collection:<ref>"),
+    field: TARGET("namespace.key, e.g. custom.care")
+  },
+  async (args) => {
+    const [owner, field] = positionals(args);
+    const [namespace, ...rest] = (field ?? "").split(".");
+    if (!owner || !namespace || rest.length === 0) failValidation("pass the owner and the field as namespace.key");
+    await stage([{ kind: "shopify.metafield.delete", target: owner, payload: { namespace, key: rest.join(".") } }]);
+  }
+);
+var collectionCreate = leaf(
+  "shopify.change.collection.create",
+  {
+    name: "create",
+    description: 'Create a collection of hand-picked products, shown on the online store (a second change, staged with it) unless --hidden. Example: baker shopify change collection create --title "Summer boards" --products snowboard-a,snowboard-b. Collections whose products join by rules are made in Shopify.'
+  },
+  {
+    title: { type: "string", description: "Title", required: false },
+    handle: {
+      type: "string",
+      description: "Its address (/collections/<handle>); default from the title",
+      required: false
+    },
+    description: { type: "string", description: "Description, as HTML (no scripts or frames)", required: false },
+    "seo-title": { type: "string", description: "Title shown in search results", required: false },
+    "seo-description": { type: "string", description: "Description shown in search results", required: false },
+    products: {
+      type: "string",
+      description: "Products, comma separated (ids, handles or links), in order",
+      required: false
+    },
+    sort: {
+      type: "string",
+      description: "MANUAL | BEST_SELLING | ALPHA_ASC | ALPHA_DESC | PRICE_ASC | PRICE_DESC | CREATED | CREATED_DESC",
+      required: false
+    },
+    hidden: { type: "boolean", description: "Don't show it on the online store yet", required: false },
+    ...JSON_ARGS
+  },
+  async (args) => await stageFor(
+    "shopify.collection.create",
+    args,
+    () => defined({
+      title: args.title,
+      handle: args.handle,
+      descriptionHtml: args.description,
+      seo: args["seo-title"] !== void 0 || args["seo-description"] !== void 0 ? defined({ title: args["seo-title"], description: args["seo-description"] }) : void 0,
+      products: list(args.products),
+      sortOrder: typeof args.sort === "string" ? args.sort.toUpperCase() : void 0,
+      onlineStore: args.hidden === true ? false : void 0
+    })
+  )
+);
+var collectionUpdate = leaf(
+  "shopify.change.collection.update",
+  {
+    name: "update",
+    description: `Change a collection's title, description, SEO or sort order (its address stays: stage a redirect to move it). Example: baker shopify change collection update summer-boards --title "Summer"`
+  },
+  {
+    collection: TARGET("Collection id, handle or link"),
+    title: { type: "string", description: "New title", required: false },
+    description: { type: "string", description: "New description, as HTML", required: false },
+    "seo-title": { type: "string", description: "Title shown in search results", required: false },
+    "seo-description": { type: "string", description: "Description shown in search results", required: false },
+    sort: { type: "string", description: "Sort order (see collection create)", required: false },
+    ...JSON_ARGS
+  },
+  async (args) => await stageFor(
+    "shopify.collection.update",
+    args,
+    () => defined({
+      title: args.title,
+      descriptionHtml: args.description,
+      seo: args["seo-title"] !== void 0 || args["seo-description"] !== void 0 ? defined({ title: args["seo-title"], description: args["seo-description"] }) : void 0,
+      sortOrder: typeof args.sort === "string" ? args.sort.toUpperCase() : void 0
+    }),
+    () => target2(args, "collection")
+  )
+);
+function collectionVerb(verb, kind, description2) {
+  return leaf(
+    `shopify.change.collection.${verb}`,
+    { name: verb, description: description2 },
+    { collection: TARGET("Collection id, handle, link or a shopify_temp_ ref staged in this chat") },
+    async (args) => await stage([{ kind, target: target2(args, "collection") }])
+  );
+}
+function membership(verb, kind, description2) {
+  return leaf(
+    `shopify.change.collection.${verb}`,
+    { name: verb, description: description2 },
+    {
+      collection: TARGET("Collection id, handle, link or a shopify_temp_ ref"),
+      products: TARGET("Products (ids, handles or links), space separated")
+    },
+    async (args) => {
+      const [collection, ...products] = positionals(args);
+      if (!collection || products.length === 0) failValidation("pass the collection, then the products");
+      await stage([{ kind, target: collection, payload: { products } }]);
+    }
+  );
+}
+function discountValue(args) {
+  if (args.percent !== void 0) return { percentage: Number(args.percent) };
+  if (args.amount !== void 0) return { amount: args.amount };
+  return void 0;
+}
+function appliesToOf(args) {
+  const products = list(args.products);
+  if (products) return { products };
+  const collections = list(args.collections);
+  return collections ? { collections } : { all: true };
+}
+function combinesOf(value) {
+  const combines = list(value) ?? [];
+  if (combines.length === 0) return void 0;
+  return {
+    productDiscounts: combines.includes("product"),
+    orderDiscounts: combines.includes("order"),
+    shippingDiscounts: combines.includes("shipping")
+  };
+}
+function numberOf(value) {
+  return value === void 0 ? void 0 : Number(value);
+}
+function discountPayload(args) {
+  return defined({
+    code: args.code,
+    title: args.title,
+    value: discountValue(args),
+    appliesTo: appliesToOf(args),
+    minimumSubtotal: args["min-subtotal"],
+    minimumQuantity: numberOf(args["min-quantity"]),
+    startsAt: args.starts,
+    endsAt: args.ends,
+    usageLimit: numberOf(args.limit),
+    oncePerCustomer: args["any-times"] === true ? false : void 0,
+    combinesWith: combinesOf(args.combines)
+  });
+}
+function signupOfferFlagsProblem(args) {
+  if (typeof args.name !== "string" || args.name.trim() === "")
+    return 'Add --name "<what shoppers and store staff see, e.g. 10% off>": every sign-up offer needs a name.';
+  if (args["valid-days"] === void 0)
+    return "Add --valid-days <1-365>: how many days each code lasts after it is given.";
+  return void 0;
+}
+function signupOfferPayload(args) {
+  return defined({
+    name: args.name,
+    value: discountValue(args),
+    appliesTo: appliesToOf(args),
+    minimumSubtotal: args.minimum,
+    validForDays: numberOf(args["valid-days"]),
+    endsAt: args.ends,
+    maxCodes: numberOf(args["max-codes"]),
+    codePrefix: args.prefix,
+    combinesWith: combinesOf(args.combines)
+  });
+}
+var signupOfferSet = leaf(
+  "shopify.change.signupOffer.set",
+  {
+    name: "set",
+    description: 'Stage a sign-up offer. Changes money: ask the exact approval question returned by this command. Example: baker shopify change signup-offer set welcome-10 --name "Welcome" --percent 10 --valid-days 14 --max-codes 1000'
+  },
+  {
+    handle: TARGET("Offer handle, e.g. welcome-10"),
+    name: {
+      type: "string",
+      description: 'Offer name shoppers and store staff see (required), e.g. "10% off"',
+      required: false
+    },
+    percent: { type: "string", description: "Percentage off (choose percent or amount)", required: false },
+    amount: { type: "string", description: "Amount off in the store currency", required: false },
+    products: { type: "string", description: "Product handles or ids, comma separated", required: false },
+    collections: { type: "string", description: "Collection handles or ids, comma separated", required: false },
+    minimum: { type: "string", description: "Minimum subtotal", required: false },
+    "valid-days": { type: "string", description: "Each code lasts 1\u2013365 days (required)", required: false },
+    ends: { type: "string", description: "Offer end as ISO date and time; no code outlives it", required: false },
+    "max-codes": { type: "string", description: "Total codes the offer may give, 1\u2013100000", required: false },
+    prefix: { type: "string", description: "Code prefix: 2\u201312 uppercase letters or digits", required: false },
+    combines: {
+      type: "string",
+      description: "Comma-separated product,order,shipping discounts to combine",
+      required: false
+    },
+    ...JSON_ARGS
+  },
+  async (args) => await stageFor(
+    "shopify.signupOffer.set",
+    args,
+    () => {
+      const problem = signupOfferFlagsProblem(args);
+      if (problem) failValidation(problem);
+      return signupOfferPayload(args);
+    },
+    () => target2(args, "offer handle")
+  )
+);
+var signupOfferEnd = leaf(
+  "shopify.change.signupOffer.end",
+  {
+    name: "end",
+    description: "End a sign-up offer at Publish. Existing codes keep their terms. Example: baker shopify change signup-offer end welcome-10"
+  },
+  { handle: TARGET("Offer handle") },
+  async (args) => await stage([{ kind: "shopify.signupOffer.end", target: target2(args, "offer handle") }])
+);
+var discountCreate = leaf(
+  "shopify.change.discount.create",
+  {
+    name: "create",
+    description: "Create a discount code for everyone who has it. Changes money: the user must say yes in the chat first \u2014 the command hands you the exact question. Example: baker shopify change discount create --code SPRING10 --percent 10 --ends 2026-10-12T23:59:00Z --limit 500. Applies to everything unless --products or --collections; starts when published unless --starts."
+  },
+  {
+    code: { type: "string", description: "The code shoppers type, e.g. SPRING10", required: false },
+    title: { type: "string", description: "What the store's staff see (default: the code)", required: false },
+    percent: { type: "string", description: "Percentage off, 1-100", required: false },
+    amount: { type: "string", description: "Amount off, as a decimal in the store's currency", required: false },
+    products: { type: "string", description: "Only these products, comma separated", required: false },
+    collections: { type: "string", description: "Only these collections, comma separated", required: false },
+    "min-subtotal": { type: "string", description: "Minimum order amount", required: false },
+    "min-quantity": { type: "string", description: "Minimum number of items", required: false },
+    starts: { type: "string", description: "Start, ISO date-time (default: when published)", required: false },
+    ends: { type: "string", description: "End, ISO date-time (default: no end)", required: false },
+    limit: { type: "string", description: "Total number of uses", required: false },
+    "any-times": { type: "boolean", description: "A customer may use it more than once", required: false },
+    combines: {
+      type: "string",
+      description: "What it combines with, comma separated: product, order, shipping",
+      required: false
+    },
+    ...JSON_ARGS
+  },
+  async (args) => await stageFor("shopify.discountCode.create", args, () => discountPayload(args))
+);
+var discountStop = leaf(
+  "shopify.change.discount.stop",
+  {
+    name: "stop",
+    description: "Stop a discount code (it ends when published). Changes money: needs the user's yes. Undo puts its own dates back. Example: baker shopify change discount stop SPRING10"
+  },
+  { code: TARGET("The discount code") },
+  async (args) => await stage([{ kind: "shopify.discountCode.deactivate", target: target2(args, "code") }])
+);
+var discountDates = leaf(
+  "shopify.change.discount.dates",
+  {
+    name: "dates",
+    description: "Change when a discount code runs. Changes money: needs the user's yes. Example: baker shopify change discount dates SPRING10 --starts 2026-10-01T00:00:00Z --ends never"
+  },
+  {
+    code: TARGET("The discount code"),
+    starts: { type: "string", description: "Start, ISO date-time", required: false },
+    ends: { type: "string", description: 'End, ISO date-time, or "never"', required: false }
+  },
+  async (args) => {
+    if (typeof args.starts !== "string" || typeof args.ends !== "string") failValidation("pass --starts and --ends");
+    await stage([
+      {
+        kind: "shopify.discountCode.schedule",
+        target: target2(args, "code"),
+        payload: { startsAt: args.starts, endsAt: args.ends === "never" ? null : args.ends }
+      }
+    ]);
+  }
+);
+var redirectCreate = leaf(
+  "shopify.change.redirect.create",
+  {
+    name: "create",
+    description: "Redirect an old address on the store to a new one (store paths, or a full https link). Example: baker shopify change redirect create --from /collections/old-boards --to /collections/summer-boards"
+  },
+  {
+    from: { type: "string", description: "The old path, starting with /", required: false },
+    to: { type: "string", description: "Where it sends shoppers: a path or an https link", required: false },
+    ...JSON_ARGS
+  },
+  async (args) => await stageFor("shopify.urlRedirect.create", args, () => defined({ from: args.from, to: args.to }))
+);
+var redirectRemove = leaf(
+  "shopify.change.redirect.remove",
+  {
+    name: "remove",
+    description: "Remove a redirect, by the path it redirects. Example: baker shopify change redirect remove /old"
+  },
+  { from: TARGET("The redirected path") },
+  async (args) => await stage([{ kind: "shopify.urlRedirect.delete", target: target2(args, "path") }])
+);
+var campaignAdd = leaf(
+  "shopify.change.campaign.add",
+  {
+    name: "add",
+    description: "Show a Baker ad campaign in the store's Shopify Marketing, so Shopify's reports credit its sales; Baker then sends its daily figures. Title, status, budget and spend come from the ad platform. Example: baker shopify change campaign add --platform google-ads --account 3865083115 --campaign 2101 --utm-campaign spring --utm-source google --utm-medium cpc"
+  },
+  {
+    platform: { type: "string", description: "google-ads | meta", required: false },
+    account: { type: "string", description: "The ad account id", required: false },
+    campaign: { type: "string", description: "The campaign id", required: false },
+    "utm-campaign": { type: "string", description: "utm_campaign its links carry", required: false },
+    "utm-source": { type: "string", description: "utm_source", required: false },
+    "utm-medium": { type: "string", description: "utm_medium", required: false }
+  },
+  async (args) => await stage([
+    {
+      kind: "shopify.marketingActivity.upsert",
+      payload: {
+        platform: args.platform,
+        accountId: args.account,
+        campaignId: args.campaign,
+        utm: { campaign: args["utm-campaign"], source: args["utm-source"], medium: args["utm-medium"] }
+      }
+    }
+  ])
+);
+var campaignRemove = leaf(
+  "shopify.change.campaign.remove",
+  {
+    name: "remove",
+    description: "Take a Baker campaign out of Shopify Marketing. Example: baker shopify change campaign remove google-ads:3865083115:2101"
+  },
+  { campaign: TARGET("<platform>:<account>:<campaign>") },
+  async (args) => await stage([{ kind: "shopify.marketingActivity.delete", target: target2(args, "campaign") }])
+);
+var measurementReconnect = leaf(
+  "shopify.change.measurement.reconnect",
+  {
+    name: "reconnect",
+    description: "Reconnect Baker's measurement on the store (the fix `baker shopify tracking audit` names when it is gone). Applies when published; Baker also repairs it on its own once a day."
+  },
+  {},
+  async () => await stage([{ kind: "shopify.webPixel.update" }])
+);
+var group = (name, description2, subCommands) => defineCommand3({ meta: { name, description: description2 }, subCommands });
+var changeCommand = defineCommand3({
+  meta: {
+    name: "change",
+    description: `Stage a change to the connected store. Nothing changes until the user publishes the chat; every
+change can be put back with \`baker shopify undo\`. Prices and discounts need the user's yes first.
+
+  baker shopify change product update <product> --title \u2026 --seo-title \u2026 --add-tags a,b
+  baker shopify change variant update <variantId> --sku \u2026 --barcode \u2026 --price \u2026
+  baker shopify change field set product:<product> --namespace custom --key \u2026 --type \u2026 --value \u2026
+  baker shopify change collection create --title \u2026 --products a,b
+  baker shopify change discount create --code SPRING10 --percent 10 --ends <iso>
+  baker shopify change redirect create --from /old --to /new
+  baker shopify change campaign add --platform google-ads --account \u2026 --campaign \u2026
+  baker shopify change measurement reconnect`
+  },
+  subCommands: {
+    "signup-offer": group("signup-offer", "Stage or end a sign-up offer", { set: signupOfferSet, end: signupOfferEnd }),
+    product: group("product", "Change a product's title, description, SEO, tags or type", { update: productUpdate }),
+    variant: group("variant", "Change an option's SKU, barcode, weight or price", { update: variantUpdate }),
+    field: group("field", "Set or remove a custom field", { set: fieldSet, remove: fieldRemove }),
+    collection: group("collection", "Create, change, show, hide, fill or delete a collection", {
+      create: collectionCreate,
+      update: collectionUpdate,
+      show: collectionVerb(
+        "show",
+        "shopify.collection.publish",
+        "Show a collection on the online store. Example: baker shopify change collection show summer-boards"
+      ),
+      hide: collectionVerb(
+        "hide",
+        "shopify.collection.unpublish",
+        "Hide a collection from the online store. Example: baker shopify change collection hide summer-boards"
+      ),
+      delete: collectionVerb(
+        "delete",
+        "shopify.collection.delete",
+        "Delete a collection \u2014 only one undo could rebuild exactly (hand-picked products, no image, no custom fields, no discount or menu pointing at it); refused otherwise with the reason. Stage a redirect for its address. Example: baker shopify change collection delete old-boards"
+      ),
+      add: membership(
+        "add",
+        "shopify.collection.addProducts",
+        "Add products to a collection. Example: baker shopify change collection add summer-boards snowboard-a snowboard-b"
+      ),
+      remove: membership(
+        "remove",
+        "shopify.collection.removeProducts",
+        "Remove products from a collection. Example: baker shopify change collection remove summer-boards snowboard-a"
+      )
+    }),
+    discount: group("discount", "Create, stop or reschedule a discount code (needs the user's yes)", {
+      create: discountCreate,
+      stop: discountStop,
+      dates: discountDates
+    }),
+    redirect: group("redirect", "Create or remove a redirect", { create: redirectCreate, remove: redirectRemove }),
+    campaign: group("campaign", "Show or remove a Baker campaign in Shopify Marketing", {
+      add: campaignAdd,
+      remove: campaignRemove
+    }),
+    measurement: group("measurement", "Reconnect Baker's measurement on the store", {
+      reconnect: measurementReconnect
+    })
+  }
+});
+
+// src/commands/shopify/changes.ts
+var changesCommand = leaf(
+  "shopify.changes",
+  {
+    name: "changes",
+    description: "The changes Baker made to the store, newest first, each with its changeId and whether it can be undone. Example: baker shopify changes --limit 20 (or --chat <id> for one chat's)."
+  },
+  {
+    limit: { type: "string", description: "How many, 1-100 (default 20)", required: false },
+    chat: { type: "string", description: "Only one chat's changes", required: false }
+  },
+  async (args) => {
+    try {
+      const data = await apiGet(
+        "/api/shopify/changes",
+        params({ limit: args.limit, chatId: args.chat })
+      );
+      writeJson({ ok: true, hints: changesHints(data), data });
+    } catch (err) {
+      failChange(err);
+    }
+  }
+);
+var undoCommand = leaf(
+  "shopify.undo",
+  {
+    name: "undo",
+    description: "Stage the change that puts an applied store change back, read from the store as it was before it \u2014 applied when the user publishes, like any change. Prices and discounts ask the user again. Refused when the store changed since. Example: baker shopify undo <changeId> [<changeId>\u2026]"
+  },
+  { changeIds: { type: "positional", description: "changeIds from `baker shopify changes`", required: false } },
+  async (args) => {
+    const changeIds = Array.isArray(args._) ? args._.filter((value) => typeof value === "string") : [];
+    if (changeIds.length === 0) failValidation("pass the changeIds to undo (see `baker shopify changes`)");
+    try {
+      const data = await apiPost("/api/shopify/undo", {
+        chatId: requireChatId(),
+        changeIds
+      });
+      emitStage(data);
+    } catch (err) {
+      failChange(err);
+    }
+  }
+);
+
+// src/commands/shopify/draft.ts
+import { defineCommand as defineCommand4 } from "citty";
+function refOf(args) {
+  const [ref] = Array.isArray(args._) ? args._ : [];
+  if (typeof ref !== "string" || ref === "")
+    failValidation("pass the staged change's ref (see `baker shopify draft list`)");
+  return ref;
+}
+function listHints(data) {
+  if (data.status === "none" || data.count === 0) return ["No store changes are staged on this chat."];
+  if (data.status === "active") {
+    return [
+      "Staged only: these apply when the user publishes the chat. Correct one with `baker shopify draft amend <ref>`, drop one with `remove`."
+    ];
+  }
+  const failed = data.ops.filter((op) => op.result?.status === "failed" || op.result?.status === "skipped");
+  return failed.length > 0 ? [`${failed.length} of ${data.count} changes did not go through \u2014 say which and why; never report them as made.`] : [];
+}
+var list2 = leaf(
+  "shopify.draft.list",
+  {
+    name: "list",
+    description: "Start here to review the store changes staged on this chat (or another chat's with --chat): what each is, whether it changes money, and after publish what happened to it."
+  },
+  { chat: CHAT_READ_ARG },
+  async (args) => {
+    try {
+      const data = await apiPost("/api/shopify/draft/list", {
+        chatId: resolveChatId(args.chat)
+      });
+      writeJson({ ok: true, hints: listHints(data), data });
+    } catch (err) {
+      failChange(err);
+    }
+  }
+);
+var show = leaf(
+  "shopify.draft.show",
+  {
+    name: "show",
+    description: "One staged store change in full: what it sends and the store as it was read when it was staged (the before)."
+  },
+  { ref: { type: "positional", description: "The staged change's ref", required: false }, chat: CHAT_READ_ARG },
+  async (args) => {
+    try {
+      const data = await apiPost("/api/shopify/draft/show", { chatId: resolveChatId(args.chat), ref: refOf(args) });
+      writeJson({ ok: true, data });
+    } catch (err) {
+      failChange(err);
+    }
+  }
+);
+var amend = leaf(
+  "shopify.draft.amend",
+  {
+    name: "amend",
+    description: `Correct a staged change in place: a JSON patch merged into its payload (objects merge, null removes a key) and every check run again \u2014 a changed price asks the user again. Example: baker shopify draft amend product:123 --patch '{"title":"Better"}'. Keys are the payload's, not the flags': productType (not type), seo {title, description}, addTags, compareAtPrice; a key it doesn't take is refused with the ones it does.`
+  },
+  {
+    ref: { type: "positional", description: "The staged change's ref", required: false },
+    patch: { type: "string", description: "Inline JSON patch", required: false },
+    file: { type: "string", description: "A JSON file with the patch", required: false }
+  },
+  async (args) => {
+    try {
+      const data = await apiPost("/api/shopify/draft/amend", {
+        chatId: requireChatId(),
+        ref: refOf(args),
+        patch: loadJsonArg(args, "patch")
+      });
+      emitStage(data);
+    } catch (err) {
+      failChange(err);
+    }
+  }
+);
+var remove = leaf(
+  "shopify.draft.remove",
+  {
+    name: "remove",
+    description: "Drop one staged store change, and any change that needs it (a new collection's show)."
+  },
+  { ref: { type: "positional", description: "The staged change's ref", required: false } },
+  async (args) => {
+    try {
+      writeJson({
+        ok: true,
+        data: await apiPost("/api/shopify/draft/remove", { chatId: requireChatId(), ref: refOf(args) })
+      });
+    } catch (err) {
+      failChange(err);
+    }
+  }
+);
+var clear = leaf(
+  "shopify.draft.clear",
+  { name: "clear", description: "Drop every store change staged on this chat." },
+  {},
+  async () => {
+    try {
+      writeJson({ ok: true, data: await apiPost("/api/shopify/draft/clear", { chatId: requireChatId() }) });
+    } catch (err) {
+      failChange(err);
+    }
+  }
+);
+var draftCommand = defineCommand4({
+  meta: { name: "draft", description: "List, show, amend, remove or clear the store changes staged on this chat" },
+  subCommands: { list: list2, show, amend, remove, clear }
+});
+
+// src/commands/shopify/promotions.ts
+import { defineCommand as defineCommand5 } from "citty";
+
+// src/commands/shopify/landingLinks.ts
+import { readdir, readFile, stat } from "fs/promises";
+import path from "path";
+import { parse } from "@astrojs/compiler/sync";
+var PAGES_MAX = 300;
+var FILE_BYTES_MAX = 256 * 1024;
+function escaped(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var BUY_COMPONENTS = /* @__PURE__ */ new Set(["ShopifyProduct", "ShopifyBuyButton"]);
+var STRING_LITERAL = /^\s*(["'`])([^"'`]*)\1\s*$/;
+var ITEM_PRODUCT = /\bproduct\s*:\s*(["'`])([^"'`]*)\1/g;
+function namedBy(attribute) {
+  if (attribute.name === "product") {
+    if (attribute.kind === "quoted" || attribute.kind === "template-literal") return [attribute.value];
+    if (attribute.kind === "expression") return [STRING_LITERAL.exec(attribute.value)?.[2] ?? ""];
+  }
+  if (attribute.name === "items" && attribute.kind === "expression") {
+    return [...attribute.value.matchAll(ITEM_PRODUCT)].map((match) => match[2] ?? "");
+  }
+  return [];
+}
+function componentProducts(node, into) {
+  if (node.type === "component" && BUY_COMPONENTS.has(node.name)) {
+    for (const attribute of node.attributes) into.push(...namedBy(attribute));
+  }
+  if ("children" in node) for (const child of node.children) componentProducts(child, into);
+  return into;
+}
+function buyComponentProducts(file) {
+  if (!file.path.endsWith(".astro")) return [];
+  try {
+    return componentProducts(parse(file.text, void 0).ast, []);
+  } catch {
+    return [];
+  }
+}
+function namesProduct(file, keys) {
+  const wanted = new Set([keys.handle.toLowerCase(), ...keys.productId ? [keys.productId] : []].filter(Boolean));
+  return buyComponentProducts(file).some((named) => wanted.has(named.trim().toLowerCase()));
+}
+function evidenceIn(file, keys) {
+  const { text } = file;
+  const evidence = [];
+  if (keys.buyUrls.some((url) => url && text.includes(url))) evidence.push("buy_link");
+  const page = new RegExp(`/products/${escaped(keys.handle)}(?![A-Za-z0-9_-])`, "i");
+  if (keys.handle && page.test(text)) evidence.push("product_page");
+  const option = keys.variantIds.some(
+    (id) => new RegExp(`(?:/cart/(?:\\d+:\\d+,)*${id}:|variant=${id}(?!\\d))`).test(text)
+  );
+  if (option) evidence.push("variant_id");
+  if (namesProduct(file, keys)) evidence.push("buy_button");
+  return evidence;
+}
+function landingLinksOf(pages, keys) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const found = new Set(page.files.flatMap((file) => evidenceIn(file, keys)));
+    if (found.size === 0) continue;
+    const slug = page.slug.replace(/--\d+$/, "");
+    const held = bySlug.get(slug) ?? /* @__PURE__ */ new Set();
+    for (const evidence of found) held.add(evidence);
+    bySlug.set(slug, held);
+  }
+  const order = ["buy_link", "product_page", "variant_id", "buy_button"];
+  return [...bySlug].map(([slug, evidence]) => ({ slug, evidence: order.filter((entry) => evidence.has(entry)) }));
+}
+async function isDir(target3) {
+  try {
+    return (await stat(target3)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function readWorkspacePages(root) {
+  const dir = path.join(root, "src/pages");
+  if (!await isDir(dir)) return null;
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const slugs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("_")).map((entry) => entry.name);
+  const pages = [];
+  for (const slug of slugs.slice(0, PAGES_MAX)) {
+    const files = [];
+    for (const file of await landingGraphFiles(root, slug)) {
+      try {
+        const absolute = path.join(root, file);
+        if ((await stat(absolute)).size > FILE_BYTES_MAX) continue;
+        files.push({ path: file, text: await readFile(absolute, "utf8") });
+      } catch {
+      }
+    }
+    pages.push({ slug, files });
+  }
+  return { pages, skipped: Math.max(0, slugs.length - PAGES_MAX) };
+}
+
+// src/commands/shopify/promotionHints.ts
+var PLATFORM = { "google-ads": "Google Ads", meta: "Meta" };
+function plural(count, one, many = `${one}s`) {
+  return `${count} ${count === 1 ? one : many}`;
+}
+function pauseCommand(ad) {
+  if (ad.platform === "meta") return `\`baker ads meta ads pause ${ad.id ?? "<id>"}\``;
+  const target3 = `${ad.resource ?? "<resource>"} --customer-id ${ad.account_id ?? "<account_id>"}`;
+  return ad.level === "asset_group" ? `\`baker ads google asset-groups update ${target3} --status PAUSED\`` : `\`baker ads google ads pause ${target3}\``;
+}
+function pauseHint(answer) {
+  if (answer.product.stock === "in_stock" || answer.ads.length === 0) return null;
+  const active = answer.ads.filter((ad) => ad.status === "active");
+  if (active.length === 0) {
+    return `Every ad that sends people to \u201C${answer.product.title}\u201D is already paused: stage nothing for it. Tell the user this run paused nothing, and promise nothing about these ads coming back when it is back in stock.`;
+  }
+  const one = active.length === 1;
+  return `${plural(active.length, "active ad")} still ${one ? "sends" : "send"} people to \u201C${answer.product.title}\u201D, which is out of stock. Stage pausing ${one ? "it" : "them"}: ${active.map(pauseCommand).join("; ")}. Each pause waits for the user to review and publish, and nothing turns it back on by itself.`;
+}
+function promotionHints(answer, scan) {
+  const hints = [];
+  const pause = pauseHint(answer);
+  if (pause) hints.push(pause);
+  if (answer.shopping.length > 0 || answer.catalog_ads > 0) {
+    hints.push(
+      "Shopping campaigns and catalog ads stop showing a product nobody can buy by themselves \u2014 never pause them for one product."
+    );
+  }
+  for (const missed of answer.checked.not_checked) {
+    hints.push(
+      `${PLATFORM[missed.platform] ?? missed.platform} could not be checked (${missed.reason}); say so rather than that nothing runs there.`
+    );
+  }
+  for (const landing of answer.landings.filter((entry) => !entry.published)) {
+    hints.push(`/${landing.slug} links to this product but is not live; no ad can send people to it yet.`);
+  }
+  if (answer.ads.length === 0 && answer.landings.length === 0 && answer.shopping.length === 0) {
+    const nothing = `Nothing advertises \u201C${answer.product.title}\u201D that Baker can see`;
+    hints.push(
+      answer.product.stock === "in_stock" ? `${nothing}.` : `${nothing}: stage nothing for it. Tell the user this run paused nothing for it, and promise nothing about ads coming back when it is back in stock.`
+    );
+  }
+  if (!scan.scanned) {
+    hints.push(
+      "This workspace's pages were not read (no src/pages here), so landings are from Baker's last scan and measured visits only."
+    );
+  } else if (scan.skippedPages > 0) {
+    hints.push(`${plural(scan.skippedPages, "page")} not checked for links to this product (past the 300-page bound).`);
+  }
+  if (!answer.remembered && answer.ads.length > 0) {
+    hints.push(
+      "This read was made outside a Session (no chat): a pause staged from it will never be offered back for restarting when the product returns."
+    );
+  }
+  return hints;
+}
+
+// src/commands/shopify/stockHoldReport.ts
+var PLATFORM2 = { "google-ads": "Google Ads", meta: "Meta" };
+var LEVEL = {
+  campaign: "campaign",
+  ad_group: "ad group",
+  ad: "ad",
+  asset_group: "asset group",
+  adset: "ad set"
+};
+function adName(ad) {
+  return `${PLATFORM2[ad.platform]} ${LEVEL[ad.level]} ${ad.name ? `\u201C${ad.name}\u201D` : ad.entity_id}`;
+}
+var GOOGLE_GROUP = {
+  campaign: "campaigns",
+  ad_group: "ad-groups",
+  ad: "ads",
+  asset_group: "asset-groups",
+  adset: "ads"
+};
+var META_GROUP = {
+  campaign: "campaigns",
+  ad_group: "adsets",
+  ad: "ads",
+  asset_group: "ads",
+  adset: "adsets"
+};
+function resumeCommand(hold) {
+  if (hold.platform === "meta") return `baker ads meta ${META_GROUP[hold.level]} resume ${hold.entity_id}`;
+  const target3 = `${hold.entity_id} --customer-id ${hold.account_id}`;
+  return hold.level === "asset_group" ? `baker ads google asset-groups update ${target3} --status ENABLED` : `baker ads google ${GOOGLE_GROUP[hold.level]} resume ${target3}`;
+}
+function quoted(title, fallback) {
+  return title ? `\u201C${title}\u201D` : fallback;
+}
+function heldLine(hold) {
+  const name = adName(hold);
+  const product = quoted(hold.product.title, "the product");
+  switch (hold.verdict) {
+    case "resumable":
+      return `Ready to turn back on when you publish: ${name} \u2014 Baker paused it because ${product} ran out.`;
+    case "still_out_of_stock":
+      return `Stays paused: ${name} \u2014 ${product} still cannot be bought.`;
+    case "changed_since":
+      return `Left as it is: ${name} \u2014 someone changed it after Baker paused it when ${product} ran out, so check it yourself.`;
+    case "still_promotes_out_of_stock":
+      return `Stays paused: ${name} \u2014 it also sends people to ${quoted(hold.verdict_detail, "another product")}, which is still out of stock.`;
+    case "cannot_confirm":
+      return `Left as it is: ${name} \u2014 Baker cannot tell whether someone changed it after pausing it when ${product} ran out, so check it before turning it back on.`;
+    case "already_active":
+      return `Nothing to do: ${name} is already running again.`;
+    default:
+      return null;
+  }
+}
+var CLOSED_HOW = {
+  resumed_by_back_in_stock_run: "turned back on by an earlier back-in-stock run",
+  changed_by_baker: "turned back on by other work published in Baker",
+  already_active: "found running again, turned back on by someone",
+  removed: "removed",
+  product_removed: "let go when the product left the store"
+};
+function plural2(count, one) {
+  return `${count} ${count === 1 ? one : `${one}s`}`;
+}
+function nothingHeldLines(answer, asked, product) {
+  if (!asked.product) {
+    return answer.holds.length > 0 ? ["None of these is still paused because its product ran out, so there is nothing to turn back on."] : ["Baker has no ad paused because a product ran out, so there is nothing to turn back on."];
+  }
+  if (answer.pending_sessions.length > 0) {
+    return [
+      `Baker's pause for ${product} is still waiting for your review and was never published, so there is nothing to turn back on.`
+    ];
+  }
+  if (answer.recently_closed.length > 0) {
+    return answer.recently_closed.map(
+      (hold) => `Already handled: Baker paused ${adName(hold)} when ${product} ran out, and it was later ${CLOSED_HOW[hold.resolved_reason]}.`
+    );
+  }
+  return [`Baker has nothing paused because ${product} ran out, so there is nothing to turn back on.`];
+}
+function stockHoldReport(answer, asked) {
+  const product = quoted(answer.product?.title, "the product that came back");
+  const held = answer.holds.filter((hold) => hold.state === "held");
+  const tell_user = [
+    ...held.length === 0 ? nothingHeldLines(answer, asked, product) : [],
+    ...held.flatMap((hold) => heldLine(hold) ?? []),
+    ...answer.not_paused.map((ad) => `Left as it is: ${adName(ad)} \u2014 Baker did not pause it when ${product} ran out.`),
+    ...answer.pending_sessions.map(
+      (pending) => `Discard the work waiting for your review, \u201C${pending.title}\u201D: it would pause ${plural2(pending.staged_pauses, "ad")} for ${product}, which can be bought again.`
+    )
+  ];
+  const resume = held.filter((hold) => hold.verdict === "resumable").map((hold) => ({ ad: adName(hold), command: resumeCommand(hold) }));
+  const pages = answer.pages_changed.map((run) => ({
+    pages: run.pages.map((slug) => `/${slug}`),
+    read: `baker chats diff ${run.chat_id} --surface landings --full`
+  }));
+  const hints = [
+    resume.length > 0 ? "Stage each `resume` command, and nothing else." : `Stage nothing${asked.product ? ` for ${product}` : ""}.`,
+    "Tell the user the `tell_user` lines as they are written, and nothing about any other ad: an ad this read does not name is not this run's to explain.",
+    ...pages.map(
+      (run) => `The out-of-stock run also changed ${run.pages.join(", ")}: read those changes with its \`read\` command, and put back only what it changed for ${product}.`
+    )
+  ];
+  const compact = { tell_user, resume, ...pages.length > 0 ? { pages } : {} };
+  if (!asked.full) return { data: compact, hints };
+  const { store: _store, ...everything } = answer;
+  return { data: { ...compact, ...everything }, hints };
+}
+
+// src/commands/shopify/promotions.ts
+registerSchema({
+  command: "shopify.promotions",
+  description: "Start here when a product runs out of stock or comes back: what is advertising it \u2014 ads on Google Ads and Meta that lead to its store page, its buy link or a landing that links to it (`via`), the landings themselves (from this workspace's pages, and from measured visits), and the Shopping campaigns and catalog ads that show it (they stop by themselves when it runs out \u2014 never pause them). Read it in the Session that pauses: a pause is remembered only for a product whose promotions that Session read, so that \u201CRestart ads when a product is back\u201D, if the company has it, can later stage turning it back on for the user to review \u2014 nothing restarts by itself, and every pause waits for the user to review and publish. `checked.not_checked` names a platform Baker could not read.",
+  args: {
+    product: { type: "positional", description: "Product id, handle, or a link to the product", required: true },
+    full: {
+      ...fullArg,
+      description: "Add each ad's campaign and ad group or ad set ids and its URL (its id, account and Google resource name are always there)"
+    }
+  }
+});
+registerSchema({
+  command: "shopify.stock-holds",
+  description: "Start here when a product is back in stock: what Baker paused because it ran out, answered for the marketer. `resume` holds the one command to stage per ad Baker may turn back on now \u2014 stage those and nothing else. `tell_user` holds one sentence per ad (and per piece of out-of-stock work still waiting for review), written for the marketer: tell them those, as written. `pages` names landings the out-of-stock run changed and the read that shows those page changes. Use `--product` for the product that came back: the answer then speaks only of its ads. `--full` adds the codes behind each sentence (verdicts, ids) for debugging, never for the user.",
+  args: {
+    product: { type: "string", description: "Only one product's holds: its id, handle or link", required: false },
+    all: { type: "boolean", description: "Resolved holds too (resumed or released)", required: false, default: false },
+    full: fullArg
+  }
+});
+function promotionsShown(answer, full) {
+  if (full) return answer;
+  const { remembered: _remembered, ...shown } = answer;
+  return shown;
+}
+var promotionsCommand = defineCommand5({
+  meta: {
+    name: "promotions",
+    description: "What advertises one product: ads that lead to it, landings that link to it, Shopping that shows it. Example: baker shopify promotions 10310413942969"
+  },
+  args: {
+    product: { type: "positional", description: "Product id, handle, or a link to the product", required: true },
+    full: {
+      type: "boolean",
+      description: "Add campaign and ad group or ad set ids and URLs",
+      required: false,
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const positionals2 = Array.isArray(args._) ? args._ : [];
+      if (positionals2.length > 1) {
+        throw new ApiError("VALIDATION_ERROR", "product: Pass one product id, handle or product link.");
+      }
+      const { product, store } = await apiGet(
+        "/api/shopify/product",
+        params({ ref: args.product })
+      );
+      const scan = await readWorkspacePages(process.cwd());
+      const linked = scan ? landingLinksOf(scan.pages, {
+        handle: product.handle,
+        productId: product.productId,
+        variantIds: product.variants.map((variant) => variant.variantId),
+        buyUrls: product.variants.flatMap((variant) => variant.buyUrl ? [variant.buyUrl] : [])
+      }) : void 0;
+      const answer = await apiPost("/api/shopify/promotions", {
+        product: product.productId,
+        ...linked ? { linked_landings: linked.slice(0, 50) } : {},
+        scanned: scan !== null,
+        ...args.full ? { full: true } : {}
+      });
+      emit(promotionsShown(answer, args.full === true), { store }, [
+        ...storeStateHints(store),
+        ...promotionHints(answer, { scanned: scan !== null, skippedPages: scan?.skipped ?? 0 })
+      ]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var stockHoldsCommand = defineCommand5({
+  meta: {
+    name: "stock-holds",
+    description: "The ads Baker paused because a product ran out, and whether each may be resumed now. Example: baker shopify stock-holds --product 10310413942969"
+  },
+  args: {
+    product: { type: "string", description: "Only one product: its id, handle or link", required: false },
+    all: { type: "boolean", description: "Resolved holds too", required: false, default: false },
+    full: { type: "boolean", description: "Everything Baker keeps", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet(
+        "/api/shopify/stock-holds",
+        params({ product: args.product, all: args.all, full: args.full })
+      );
+      const report = stockHoldReport(answer, { product: args.product !== void 0, full: args.full === true });
+      emit(report.data, { store: answer.store, count: answer.holds.length }, [
+        ...storeStateHints(answer.store),
+        ...report.hints
+      ]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+
+// ../api/src/shopify/signups.ts
+import { z as z4 } from "zod";
+var SIGNUP_CODE_PATTERN = /^[A-Z0-9]{2,12}-[0-9A-HJKMNP-TV-Z]{8}$/;
+var SIGNUP_STATES = [
+  "waiting",
+  "ready",
+  "used",
+  "expired",
+  "already",
+  "ended",
+  "none",
+  "unavailable"
+];
+var CODE_STATES = /* @__PURE__ */ new Set(["ready", "used", "expired"]);
+var shopifySignupReplySchema = z4.object({
+  state: z4.enum(SIGNUP_STATES),
+  code: z4.string().regex(SIGNUP_CODE_PATTERN).optional(),
+  endsAt: z4.string().min(1).max(40).optional()
+}).strict().refine(
+  (reply) => CODE_STATES.has(reply.state) ? reply.code !== void 0 && reply.endsAt !== void 0 : true,
+  "a code state carries the code and when it ends"
+).refine(
+  (reply) => CODE_STATES.has(reply.state) ? true : reply.code === void 0 && reply.endsAt === void 0,
+  "only the browser the code was given to is told it"
+);
+var shopifySignupResponseSchema = z4.union([
+  z4.object({ ok: z4.literal(true), signup: shopifySignupReplySchema }).passthrough(),
+  z4.object({ error: z4.string(), signup: shopifySignupReplySchema }).passthrough()
+]);
+var signupOfferStatusSchema = z4.enum(["active", "ended", "staged"]);
+var shopifySignupOfferViewSchema = z4.object({
+  handle: z4.string(),
+  name: z4.string(),
+  /** "10% off everything, each code valid 14 days, at most 1,000 codes". */
+  summary: z4.string(),
+  status: signupOfferStatusSchema,
+  validForDays: z4.number(),
+  endsAt: z4.string().optional(),
+  maxCodes: z4.number().optional(),
+  codesGiven: z4.number()
+});
+var shopifySignupOffersResponseSchema = z4.object({
+  /** The company has a store connection Baker can use (connected, not waiting on a reconnect). */
+  connected: z4.boolean(),
+  /** The store allows Baker to add customers (sign-ups work). */
+  canAddCustomers: z4.boolean(),
+  /** The store allows Baker to make discount codes (offers give codes). */
+  canGiveCodes: z4.boolean(),
+  offers: z4.array(shopifySignupOfferViewSchema),
+  /** Sign-ups the store didn't take in the last 7 days: for a missing permission, and for anything else. */
+  refusedLast7Days: z4.object({ permission: z4.number(), other: z4.number() })
+});
+
+// src/commands/shopify/signupOffers.ts
+import { defineCommand as defineCommand6 } from "citty";
+var description = "Start here for landing sign-ups: published and this chat's staged offers, codes given and store permissions. Example: baker shopify signup-offers. Forms name an offer handle; terms are staged with baker shopify change signup-offer set.";
+registerSchema({ command: "shopify.signupOffers", description, args: {} });
+var signupOffersCommand = defineCommand6({
+  meta: { name: "signup-offers", description },
+  async run() {
+    try {
+      const data = shopifySignupOffersResponseSchema.parse(
+        await apiGet("/api/shopify/signup-offers", params({ chatId: optionalChatId() }))
+      );
+      const hints = [];
+      if (!data.canAddCustomers)
+        hints.push(
+          'Sign-ups cannot be added to the store yet: call request_connection with { platform: "shopify", reason: "Add sign-ups from your landing" }. Keep building the page; the Form works once allowed.'
+        );
+      if (!data.canGiveCodes)
+        hints.push(
+          "Codes need the store to allow discounts: use request_connection for Shopify and keep building the page."
+        );
+      if (data.offers.some((offer) => offer.status === "ended"))
+        hints.push(
+          "Forms naming ended offers still add customers but give no code: stage a new offer or remove offer from the Form."
+        );
+      if (data.offers.length === 0)
+        hints.push(
+          "No sign-up offer exists yet. Omit offer for sign-ups without a code, or stage one after the user approves its terms."
+        );
+      writeJson({ ok: true, hints, data });
+    } catch (error) {
+      fail(error);
+    }
+  }
+});
+
+// src/commands/shopify/tracking.ts
+import { defineCommand as defineCommand7 } from "citty";
+var audit = leaf(
+  "shopify.tracking.audit",
+  {
+    name: "audit",
+    description: "Start here for 'is our store's tracking set up right?': Baker's measurement on the store, Baker switched on in the theme, whether orders carry Baker's visitor, who reports sales to Meta and Google, shoppers' consent, and whether the store sells through its own website. Each check is ok, problem (with its fix: a change to stage, a task for the merchant, or a decision) or unknown (with why). Reads only \u2014 it changes nothing."
+  },
+  { full: { type: "boolean", description: "Add the facts behind each check", required: false } },
+  async (args) => {
+    try {
+      const data = await apiPost("/api/shopify/tracking/audit", { full: args.full === true });
+      writeJson({ ok: true, hints: auditHints(data), data });
+    } catch (err) {
+      fail(err);
+    }
+  }
+);
+var trackingCommand = defineCommand7({
+  meta: { name: "tracking", description: "Check how the store is measured: baker shopify tracking audit" },
+  subCommands: { audit }
+});
+
+// src/commands/shopify/index.ts
+registerSchema({
+  command: "shopify.store",
+  description: 'Start here for the connected Shopify store: its name, currency, home country, how many products and collections it has, how many products are out of stock or partly out, the prices by country it sells at (only when it has more than one), where its buy links send a shopper (`buyDestination`: checkout, store_cart or product_page), its languages and policies, whether it asks for a password, and the link to the Products page in Baker. `capped: true` means a count stopped at its ceiling (100 out of stock or partly out, 500 collections): say "100 or more", never the number as exact. `meta.store` says whether Baker\'s copy is complete and whether Baker can still reach the store. `canChange` says which kinds of store change the store allows Baker to stage (products, publishing, discounts, redirects, marketing); a `false` one is allowed by the user in Shopify (`request_connection`).',
+  args: {
+    full: {
+      ...fullArg,
+      description: "Add the store's products page in Shopify admin, every country, each policy's text and the store's brand"
+    }
+  }
+});
+registerSchema({
+  command: "shopify.products",
+  description: "Start here for 'what do we sell' and 'at what price': the connected store's products with price, sale price, stock and where they can be bought. A product flagged `availability: not_for_sale` can't be bought on the online store (draft, archived or hidden from it) \u2014 never send ads or pages to it; `link_only` is buyable through its link but hidden from the store's search. Filter with --search, --stock or --collection; page with --cursor.",
+  args: {
+    search: { type: "string", description: "Words in the title, vendor, type or tags", required: false },
+    collection: {
+      type: "string",
+      description: "Only one collection's products: its handle or id (`baker shopify collections`)",
+      required: false
+    },
+    stock: {
+      type: "string",
+      description: "in_stock | partly_out (some options out) | out_of_stock (every option out)",
+      required: false,
+      enum: ["in_stock", "partly_out", "out_of_stock"]
+    },
+    limit: { type: "number", description: "Products per page, 1-100 (default 25)", required: false },
+    cursor: {
+      type: "string",
+      description: "meta.next_cursor from the previous page, with the same filters",
+      required: false
+    },
+    full: { ...fullArg, description: "Add vendor, type, option count, photo link, visibility and status" }
+  }
+});
+registerSchema({
+  command: "shopify.product",
+  description: "One product of the connected store \u2014 accepts its id, its handle, a link to it on the store, in Baker or in Shopify admin. Returns its options with price, stock and `buyUrl` (each option's buy link for ads, emails and messages; on a landing use `<ShopifyProduct>` instead \u2014 never build a Shopify link yourself, never use `storeUrl` for it), prices by country, the options out of stock, its collections, its photos' library imageIds to place on a landing (`baker images download <imageIds> --out src/pages/<page>/_images/`) or pass to a creative, its videos' playbackIds (`<Video playbackId=\u2026/>`), and `contentSummary`: what else Baker keeps about it. Start here for a landing from a product: add `--content` for the formatted description, every custom field by its name (a size chart, care instructions), the rating, subscriptions and translations; `--field <name>` returns one field whole. `--out-of-stock` lists only the options out of stock.",
+  args: {
+    ref: { type: "positional", description: "Product id, handle, or a link to the product", required: true },
+    "variants-cursor": {
+      type: "string",
+      description: "data.variantsNextCursor from the previous call: the next page of options (same flags)",
+      required: false
+    },
+    "out-of-stock": {
+      type: "boolean",
+      description: "Only the options that are out of stock, whatever their position",
+      required: false,
+      default: false
+    },
+    content: {
+      type: "boolean",
+      description: "Its whole details: formatted description, custom fields by name (long ones previewed), rating, subscriptions, YouTube/3D links, translations",
+      required: false,
+      default: false
+    },
+    field: {
+      type: "string",
+      description: 'One custom field whole, by its name or its key (e.g. "Size chart" or custom.size_chart)',
+      required: false
+    },
+    variant: {
+      type: "string",
+      description: "With --field: the option whose field to return, by its variantId (options share their fields, e.g. --field custom.fit --variant 102)",
+      required: false
+    },
+    quantity: {
+      type: "number",
+      description: "How many of the option each buy link puts in the cart, 1-99 (default 1)",
+      required: false
+    },
+    full: {
+      ...fullArg,
+      description: "Its details (as --content), whole description, SEO, category, admin link, 250 options per page with SKU, prices by country, every buy link and each option's weight, unit price, shipping and tax"
+    }
+  }
+});
+registerSchema({
+  command: "shopify.collections",
+  description: "The connected store's collections, with the handle `--collection` takes and how many products Shopify counts in each. `--full` adds each one's description, image and SEO.",
+  args: {
+    search: { type: "string", description: "Words in the collection's title or handle", required: false },
+    full: { ...fullArg, description: "Add each collection's description, image and SEO" }
+  }
+});
+registerSchema({
+  command: "shopify.stock",
+  description: "Start here for 'what's out of stock': every product with every option out of stock, and every product with some options out, naming them. An option that keeps selling at zero or doesn't track stock is not out of stock \u2014 a buyer can still buy it.",
+  args: {
+    collection: { type: "string", description: "Only one collection: its handle or id", required: false },
+    limit: { type: "number", description: "Products per list, 1-200 (default 50)", required: false },
+    full: { ...fullArg, description: "Add each option's SKU and each product's Baker link" }
+  }
+});
+registerSchema({
+  command: "shopify.sales",
+  description: "Start here for 'how much did we sell', 'which campaigns or pages brought sales' and 'which products sold most': the connected store's orders, sales, refunds and net, in the store's currency. --by day (default) and --by product count each sale, addition and refund in the period it happened; --by campaign and --by landing take the orders paid in the period and credit each to the campaign or Baker page that brought its buyer, with what was added to and refunded on it since \u2014 so the rows add up to `totals` exactly, with named rows for sales from before Baker measured the store and sales from no campaign. A sale counts when it is paid, at what was received. `salesReporting` says who reports the sales to Meta and Google: `undecided` and `shopify_channel` mean Baker only reports them, and only a manager can change that in Brain \u2192 Store. --by weekday|hour|month|month_of_year says when buyers order, in the store's own time, from the store's whole order history (orders placed in the period, with what was refunded on them since): use it for when to run or schedule campaigns; only these take --days up to 3650 or --all.",
+  args: {
+    days: {
+      type: "number",
+      description: "The last N days: 1-395 by day, product, campaign or landing; 1-3650 by weekday, hour or month (default 30)",
+      required: false
+    },
+    all: {
+      type: "boolean",
+      description: "Every order the store has (by weekday, hour, month or month_of_year only)",
+      required: false,
+      default: false
+    },
+    by: {
+      type: "string",
+      description: "day | product | campaign | landing | weekday | hour | month | month_of_year (default day)",
+      required: false,
+      enum: ["day", "product", "campaign", "landing", "weekday", "hour", "month", "month_of_year"]
+    },
+    limit: {
+      type: "number",
+      description: "Rows of a breakdown, 1-100 (by campaign or landing the rest are folded into one 'other' row)",
+      required: false
+    },
+    full: {
+      ...fullArg,
+      description: "Add each row's source, medium, campaign, click platform, landing id or product id"
+    }
+  }
+});
+var salesCommand = defineCommand8({
+  meta: {
+    name: "sales",
+    description: "What the store sold: orders, sales, refunds and net, by day, product, campaign or landing \u2014 or when buyers order (weekday, hour, month). Example: baker shopify sales --days 7 --by campaign"
+  },
+  args: {
+    days: {
+      type: "string",
+      description: "The last N days (1-395; up to 3650 by weekday, hour or month)",
+      required: false
+    },
+    all: {
+      type: "boolean",
+      description: "Every order (by weekday, hour or month only)",
+      required: false,
+      default: false
+    },
+    by: {
+      type: "string",
+      description: "day | product | campaign | landing | weekday | hour | month | month_of_year (default day)",
+      required: false
+    },
+    limit: { type: "string", description: "Rows of a breakdown, 1-100", required: false },
+    full: { type: "boolean", description: "Add sources, campaigns and ids per row", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet(
+        "/api/shopify/sales",
+        params({ days: args.days, all: args.all, by: args.by, limit: args.limit, full: args.full })
+      );
+      const { store, salesReporting, history, ...data } = answer;
+      emit(data, { store, salesReporting, history }, [...storeStateHints(store), ...salesHints(answer)]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var storeCommand = defineCommand8({
+  meta: {
+    name: "store",
+    description: "The connected Shopify store: currency, countries, how many products, what is out of stock. Example: baker shopify store"
+  },
+  args: {
+    full: { type: "boolean", description: "Add the admin link and every country", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet("/api/shopify/store", params({ full: args.full }));
+      const data = answer.canChange ? { ...answer.summary, canChange: answer.canChange } : answer.summary;
+      emit(data, { store: answer.store }, [...storeStateHints(answer.store), ...storeHints(answer.summary)]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var productsCommand = defineCommand8({
+  meta: {
+    name: "products",
+    description: 'What the store sells, with price and stock. Example: baker shopify products --search "snowboard" --stock out_of_stock'
+  },
+  args: {
+    search: { type: "string", description: "Words in the title, vendor, type or tags", required: false },
+    collection: { type: "string", description: "A collection's handle or id", required: false },
+    stock: { type: "string", description: "in_stock | partly_out | out_of_stock", required: false },
+    limit: { type: "string", description: "Products per page, 1-100 (default 25)", required: false },
+    cursor: { type: "string", description: "meta.next_cursor from the previous page", required: false },
+    full: {
+      type: "boolean",
+      description: "Add vendor, type, photo link, visibility, status",
+      required: false,
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet(
+        "/api/shopify/products",
+        params({
+          search: args.search,
+          collection: args.collection,
+          stock: args.stock,
+          limit: args.limit,
+          cursor: args.cursor,
+          full: args.full
+        })
+      );
+      const filtered = Boolean(args.search || args.collection || args.stock);
+      emit(
+        answer.products,
+        {
+          store: answer.store,
+          count: answer.products.length,
+          ...answer.nextCursor ? { next_cursor: answer.nextCursor } : {}
+        },
+        [...storeStateHints(answer.store), ...productsHints(answer, { filtered, paged: Boolean(args.cursor) })]
+      );
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var productCommand = defineCommand8({
+  meta: {
+    name: "product",
+    description: "One product: options with buy links, prices by country, stock, photo imageIds, video playbackIds. Accepts an id, handle or link. Example: baker shopify product the-complete-snowboard --content"
+  },
+  args: {
+    ref: { type: "positional", description: "Product id, handle, or a link to the product", required: true },
+    "variants-cursor": {
+      type: "string",
+      description: "data.variantsNextCursor from the previous call",
+      required: false
+    },
+    "out-of-stock": { type: "boolean", description: "Only the options out of stock", required: false, default: false },
+    content: {
+      type: "boolean",
+      description: "Its whole details: formatted description, custom fields, subscriptions, translations",
+      required: false,
+      default: false
+    },
+    field: { type: "string", description: "One custom field whole, by its name or key", required: false },
+    variant: {
+      type: "string",
+      description: "With --field: the option whose field it is, by its variantId",
+      required: false
+    },
+    quantity: {
+      type: "string",
+      description: "How many each buy link puts in the cart, 1-99 (default 1)",
+      required: false
+    },
+    full: { type: "boolean", description: "Everything Baker keeps about it", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const positionals2 = Array.isArray(args._) ? args._ : [];
+      if (positionals2.length > 1) {
+        throw new ApiError(
+          "VALIDATION_ERROR",
+          "ref: Pass one product id, handle or product link \u2014 quote a link, and search by words with `baker shopify products --search`."
+        );
+      }
+      const answer = await apiGet(
+        "/api/shopify/product",
+        params({
+          ref: args.ref,
+          variantsCursor: args["variants-cursor"],
+          outOfStock: args["out-of-stock"],
+          content: args.content,
+          field: args.field,
+          variant: args.variant,
+          quantity: args.quantity,
+          full: args.full
+        })
+      );
+      emit(answer.product, { store: answer.store }, [
+        ...storeStateHints(answer.store),
+        ...productHints(answer.product, answer.store)
+      ]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var collectionsCommand = defineCommand8({
+  meta: {
+    name: "collections",
+    description: "The store's collections, with the handles --collection takes. Example: baker shopify collections --full"
+  },
+  args: {
+    search: { type: "string", description: "Words in the title or handle", required: false },
+    full: { type: "boolean", description: "Add description, image and SEO", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet(
+        "/api/shopify/collections",
+        params({ search: args.search, full: args.full })
+      );
+      emit(
+        answer.collections,
+        { store: answer.store, count: answer.collections.length },
+        storeStateHints(answer.store)
+      );
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var stockCommand = defineCommand8({
+  meta: {
+    name: "stock",
+    description: "Every product with options out of stock, naming them. Example: baker shopify stock"
+  },
+  args: {
+    collection: { type: "string", description: "A collection's handle or id", required: false },
+    limit: { type: "string", description: "Products per list, 1-200 (default 50)", required: false },
+    full: { type: "boolean", description: "Add SKUs and Baker links", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const answer = await apiGet(
+        "/api/shopify/stock",
+        params({ collection: args.collection, limit: args.limit, full: args.full })
+      );
+      const { store, ...data } = answer;
+      const limit2 = Number(args.limit ?? 50);
+      emit(data, { store }, [...storeStateHints(store), ...stockHints(answer, Number.isFinite(limit2) ? limit2 : 50)]);
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var shopifyCommand = defineCommand8({
+  meta: {
+    name: "shopify",
+    description: `Read the connected Shopify store as Baker keeps it \u2014 products, prices by country, stock, collections,
+product photos, what it sold, who buys, where and what, and what advertises each product \u2014 and stage
+changes to it (\`change\`), applied when the user publishes the chat and undone with \`undo\`.
+
+Examples:
+  baker shopify store                                # currency, countries, how many products, what is out of stock
+  baker shopify products --search "snowboard"        # what we sell, with price and stock
+  baker shopify products --stock out_of_stock        # --stock in_stock|partly_out|out_of_stock, --collection <handle>
+  baker shopify product the-complete-snowboard       # one product: options with buyUrl, prices, photos, videos
+  baker shopify product <handle> --content           # its whole details: description, custom fields, subscriptions
+  baker shopify product <handle> --field "Size chart" # one custom field, whole
+  baker shopify product <handle> --field custom.fit --variant <variantId> # one option's field, whole
+  baker shopify product <handle> --quantity 2        # buy links that put 2 in the cart
+  baker shopify product <id> --out-of-stock          # only its options that are out of stock
+  baker shopify stock                                # every product with options out of stock
+  baker shopify collections                          # collections, with handles for --collection
+  baker shopify sales --days 7 --by campaign         # what sold and which campaigns brought it (--by day|product|landing)
+  baker shopify sales --all --by weekday             # when buyers order, in the store's time (--by hour|month|month_of_year)
+  baker shopify countries --days 90                  # where buyers are, with growth (--country DE for its regions)
+  baker shopify best-sellers --days 90               # what sells (--view variants|trend|together|repeat|momentum)
+  baker shopify buyers --days 90 --by channel        # who buys, repeat rate, segments, value by acquisition channel
+  baker shopify buyer 1042                           # one numbered customer's orders
+  baker shopify segments                             # best, loyal, at risk, new, one-time \u2014 and who to find more of
+  baker shopify cohorts --months 12                  # buyers by first-order month: who came back
+  baker shopify promotions <product>                 # what advertises it: ads, landings, Shopping (read before pausing)
+  baker shopify stock-holds --product <product>      # what Baker paused because it ran out: what to resume, what to tell the user
+  baker shopify change product update <product> --title "\u2026"  # stage a store change (product|variant|field|collection|discount|redirect|campaign|measurement)
+  baker shopify draft list                           # the store changes staged on this chat
+  baker shopify changes                              # what Baker changed in the store; baker shopify undo <changeId> puts one back
+  baker shopify tracking audit                       # is the store measured right? (reads only)
+
+Product photos are already in the image library: place them by imageId
+(baker images download <imageIds> --out src/pages/<page>/_images/), never by a cdn.shopify.com link.
+Product videos are in the video library: place them with <Video playbackId="\u2026" />.
+On a landing, the buy button is <ShopifyProduct product="\u2026"/> \u2014 never a buyUrl or a Shopify link
+written by hand. buyUrl is for ads, emails and messages; never use storeUrl (a page to look at) for it.
+NO_SHOPIFY_CONNECTION means no store is connected: follow error.fix. SHOPIFY_NOT_AVAILABLE means it cannot be
+connected here yet: carry on without it.
+Full guide: __tooling__/docs/tools/baker/shopify.md`
+  },
+  subCommands: {
+    "signup-offers": signupOffersCommand,
+    store: storeCommand,
+    products: productsCommand,
+    product: productCommand,
+    collections: collectionsCommand,
+    stock: stockCommand,
+    sales: salesCommand,
+    buyers: buyersCommand,
+    buyer: buyerCommand,
+    countries: countriesCommand,
+    "best-sellers": bestSellersCommand,
+    cohorts: cohortsCommand,
+    segments: segmentsCommand,
+    promotions: promotionsCommand,
+    "stock-holds": stockHoldsCommand,
+    change: changeCommand,
+    draft: draftCommand,
+    changes: changesCommand,
+    undo: undoCommand,
+    tracking: trackingCommand
+  }
+});
+export {
+  shopifyCommand
+};
+//# sourceMappingURL=shopify-RQKO5TMR.js.map