@koda-sl/baker-cli 0.370.0-dev.0cc0d2b86 → 0.370.0-dev.886bf7ec3

package/README.md

@@ -3692,16 +3692,21 @@ baker shopify store                                # name, currency, home countr
 baker shopify products --search "snowboard"        # what the store sells: price, sale price, stock, where it can be bought
 baker shopify products --stock out_of_stock        # --stock in_stock|partly_out|out_of_stock, --collection <handle|id>
 baker shopify products --limit 10 --cursor <c>     # page with meta.next_cursor (25 by default, up to 100)
-baker shopify product <id|handle|link>             # one product: options, prices by country, stock, photo imageIds
+baker shopify product <id|handle|link>             # one product: options with buyUrl, prices by country, stock, photos, videos
+baker shopify product <handle> --content           # its whole details: description, custom fields, subscriptions, translations
+baker shopify product <handle> --field "Size chart" # one custom field, whole
+baker shopify product <handle> --quantity 2        # buy links that put 2 of the option in the cart
 baker shopify product <id> --out-of-stock          # only the options that are out of stock (page with --variants-cursor)
-baker shopify collections --search "summer"        # collections, with the handle --collection takes
+baker shopify collections --search "summer"        # collections, with the handle --collection takes (--full: descriptions, images)
 baker shopify stock --limit 20                     # every product with every option out, and every product with some out
 ```
 
 **`meta.store`** is on every answer: `connection` (`connected` · `needs_reconnect` · `disconnected`), `catalog` (`starting` · `importing` · `ready` · `failed`, with `importProgress` while importing), `unreadable` (products Baker couldn't read; `unreadableCapped` past 100), `checksFailing` (Baker couldn't check the store for changes lately), `storefront` (`online_store`, or `own` for a store that sells through its own site) and `lastActivity` (when Baker last heard from the store — not a promise the copy is current). `hints[]` turn each of these into what to tell the user.
 **`store`:** `--full` adds the admin link and every country. `capped: true` means a count stopped at its ceiling — `outOfStock` and `partlyOut` at 100, `collections` at 500 — so that count reads "that many or more"; a hint says which.
 **`products`:** `--search <words>`, `--collection <handle|id>`, `--stock`, `--limit <1-100>`, `--cursor`; `--full` adds vendor, type, option count, photo link, visibility and status. Every price, here and in `product` (`price`, `compareAt`, each option's price, `pricesByCountry`), is one string with its currency beside each amount: `"USD 785.95"`, `"USD 9.95 – USD 49.95"`. A row's `availability` is absent when the product is on the store, `link_only` when it is buyable only through its link, `not_for_sale` (with `status`) when it can't be bought on the online store.
-**`product`:** positional `<ref>` — the numeric id, the handle, a store product link (`…/products/<handle>`, even an all-digit handle), a Baker Products link, a Shopify admin product link (`admin.shopify.com/store/<shop>/products/<n>`), or `gid://shopify/Product/<n>`. Returns options (50 per page, `--variants-cursor` for more; 250 with `--full`), `outOptions` (up to 50, `outOptionsMore` for the rest), `pricesByCountry` when the store sells at more than one price, `photos[]` (`imageId` + a Baker-hosted `url`, never a Shopify link), `url` (the product's page in Baker) and `storeUrl`. `--full` adds the whole description, SEO, category, the admin link and each option's SKU, barcode, feed id and prices by country. `NOT_FOUND` carries a hint to search instead.
+**`product`:** positional `<ref>` — the numeric id, the handle, a store product link (`…/products/<handle>`, even an all-digit handle), a Baker Products link, a Shopify admin product link (`admin.shopify.com/store/<shop>/products/<n>`), or `gid://shopify/Product/<n>`. Returns options (50 per page, `--variants-cursor` for more; 250 with `--full`), `outOptions` (up to 50, `outOptionsMore` for the rest), `pricesByCountry` when the store sells at more than one price, `photos[]` (`imageId` + a Baker-hosted `url`, never a Shopify link), `url` (the product's page in Baker) and `storeUrl` (the product's page on the store — never a buy button's link). `--full` adds the whole description, SEO, category, the admin link and each option's SKU, barcode, feed id and prices by country. `NOT_FOUND` carries a hint to search instead.
+
+**Details and buy links (`product`):** every option carries `buyUrl` — the link for a page's buy button, following the store's own setting (`buyDestination`: `checkout`, `store_cart` or `product_page`) — with `buyUrlKind`, `unavailable` when it can't be bought, and `notes` for what a link can't do (`password_protected`, `subscription_only`, `subscription_optional`, `own_storefront`, `details_pending`). `--quantity <1-99>` sets how many it adds. `videos[]` lists the product's videos in the library (`videoId`, `playbackId`); `contentSummary` names what else Baker keeps. `--content` adds `content`: the formatted description, every custom field by its name (long values previewed, `truncated: true`), the rating, subscriptions, bundle, YouTube/Vimeo and 3D links, translations, and `unreadable` for content the store owner hasn't let Baker read yet. `--field <name|namespace.key>` returns one field whole. `--full` adds `--content`, all three links per option and each option's weight, unit price, shipping and tax. `store` adds `buyDestination`, `passwordProtected`, `languages`, `policies` (`--full`: their text, and the store's brand).
 **`collections`:** `--search <words>`; each row has `handle`, Shopify's product count and, on a store with an online store, `onStore`.
 **`stock`:** `--collection`, `--limit <1-200>` (default 50 per list), `--full` (SKUs and Baker links). Options that keep selling at zero or don't track stock are not out of stock.
 

package/dist/cli.js

@@ -5897,7 +5897,11 @@ var REJECTION_CODES = [
   "missing_identity",
   "invalid_timestamp",
   "invalid_value",
-  "batch_too_large"
+  "batch_too_large",
+  // Appended, never inserted: the set a client branches on grows, and no code
+  // it already handles changes meaning.
+  "invalid_items",
+  "invalid_consent"
 ];
 var EVENT_INGEST_BATCH_MAX = 500;
 var EVENT_INGEST_BODY_MAX_BYTES = 8 * 1024 * 1024;
@@ -5910,12 +5914,15 @@ function validateEventName(name) {
   if (value === "" || value.length > MAX_EVENT_NAME || !EVENT_NAME.test(value)) return "invalid_name";
   return null;
 }
+var MAX_ITEM_QUANTITY = 1e6;
 var REJECTION_MESSAGES = {
   invalid_event_id: "event_id, when sent, must be 1-128 characters of A-Z a-z 0-9 . _ : -",
   invalid_name: "event_name is required: up to 80 characters of letters (any language), digits, spaces, . _ and -, starting with a letter or a digit",
   missing_identity: "user_data named nobody, and no url named a page",
   invalid_timestamp: "event_time must be an ISO-8601 instant with an offset or Unix seconds, and not in the future",
   invalid_value: "value and currency go together: a non-negative decimal and an ISO-4217 code",
+  invalid_items: "each item names a product_id, variant_id or feed_id; quantity is a whole number from 1 to 1000000; price is a non-negative decimal sent with a currency",
+  invalid_consent: "consent.analytics and consent.marketing, when sent, are granted or denied",
   batch_too_large: `a request carries at most ${EVENT_INGEST_BATCH_MAX} events and ${EVENT_INGEST_BODY_MAX_BYTES / (1024 * 1024)} MB`
 };
 
@@ -7294,7 +7301,8 @@ var TRIGGER_KINDS = {
       "utm_source",
       "utm_medium",
       "utm_campaign",
-      "properties.<name>"
+      "properties.<name>",
+      "items"
     ],
     keywords: ["purchase", "signup", "conversion", "analytics", "tracking", "hubspot", "crm", "deal", "funnel", "lead"]
   },
@@ -8136,7 +8144,8 @@ var videoSourceSchema = z29.enum([
   "twitter",
   "vimeo",
   "vk",
-  "youtube"
+  "youtube",
+  "shopify"
 ]);
 var videoTranscriptSegmentSchema = z29.object({
   text: z29.string(),
@@ -14905,8 +14914,22 @@ var ANALYTICS_EVENT_TYPES = [
    * page, `ingest` for a third party's server — and every report that needs to
    * tell them apart filters on that.
    */
-  "custom"
+  "custom",
+  /**
+   * A fact about the business that names no person — a product changed, a
+   * variant went out of stock.
+   *
+   * Only a commerce door writes it (`ingestShopifyFacts`), and it is a type of
+   * its own rather than a `custom` event with no identity for one reason:
+   * every report that lists named events whitelists `custom`, so an
+   * operational fact would otherwise appear in the conversion picker, the
+   * funnel and the sends. Here it reaches the raw feed and the agents that
+   * listen for its name, and no person-level report. The row builder blanks
+   * every identity column on it, whatever it carried.
+   */
+  "operational"
 ];
+var EVENT_ITEMS_MAX = 250;
 var ANALYTICS_DEVICE_TYPES = ["desktop", "mobile", "tablet", "bot", "unknown"];
 var ANALYTICS_BEACON_BATCH_MAX = 50;
 
@@ -30919,6 +30942,48 @@ var EVENT_FIELDS = [
     name: "properties",
     need: "optional",
     takes: "A flat object of strings \u2014 anything you want to break the event down by later."
+  },
+  {
+    name: "items",
+    need: "optional",
+    takes: "What was bought, one entry per product line \u2014 for a purchase, a cart or a refund.",
+    note: `Each line names its product by at least one of the ids below. value still carries the whole event's money. An order with more than ${EVENT_ITEMS_MAX} lines keeps the first ${EVENT_ITEMS_MAX}.`
+  },
+  {
+    name: "product_id, variant_id, feed_id",
+    need: "conditional",
+    under: true,
+    takes: "Your store's product id, its variant id, or the id the product has in your ads catalog. At least one per line, up to 255 characters each."
+  },
+  {
+    name: "quantity",
+    need: "optional",
+    under: true,
+    takes: `How many: a whole number from 1 to ${MAX_ITEM_QUANTITY.toLocaleString("en-US")}.`
+  },
+  {
+    name: "price",
+    need: "optional",
+    under: true,
+    takes: "The price of one unit, in the event's currency \u2014 so it needs currency. A decimal like value."
+  },
+  {
+    name: "consent",
+    need: "optional",
+    takes: "What the person allowed, if your site asked them.",
+    note: "Send it whenever you know it. A person who said no to marketing is still counted in your reports, and is never matched or sent to an ad platform."
+  },
+  {
+    name: "analytics",
+    need: "optional",
+    under: true,
+    takes: "granted or denied \u2014 whether they allowed being measured. Denied keeps the event and forgets who it was."
+  },
+  {
+    name: "marketing",
+    need: "optional",
+    under: true,
+    takes: "granted or denied \u2014 whether they allowed their visit to be used for advertising."
   }
 ];
 var RESPONSE_FIELDS = [
@@ -31248,7 +31313,37 @@ var ingestEventSchema = z39.strictObject({
    * left alone: masking one would rename the field and could collide with a
    * sibling.
    */
-  properties: z39.record(z39.string(), z39.string()).nullish()
+  properties: z39.record(z39.string(), z39.string()).nullish(),
+  /**
+   * What was bought, one entry per line — for a purchase, a cart, a refund.
+   *
+   * Flat and Meta-like for the same reason as the rest of this body: it is
+   * Meta's `contents` (`id`, `quantity`, `item_price`) and GA4's `items`
+   * (`item_id`, `quantity`, `price`) under one spelling a sender can map from
+   * either. A line names what it is by any of three ids — the store's product,
+   * its variant, or the id the product has in an ads catalog. `price` is the
+   * *unit* price in the event's `currency`; `value` stays the whole event's
+   * money. Structure only here; `validateItems` judges each line.
+   */
+  items: z39.array(
+    z39.strictObject({
+      product_id: z39.string().nullish(),
+      variant_id: z39.string().nullish(),
+      feed_id: z39.string().nullish(),
+      quantity: z39.union([z39.string(), z39.number()]).nullish(),
+      price: z39.union([z39.string(), z39.number()]).nullish()
+    })
+  ).nullish(),
+  /**
+   * What the person allowed, each `granted` or `denied`: `analytics` (being
+   * measured at all) and `marketing` (being matched and sent to an ad
+   * platform). Absent means the sender did not say. Enforced before anything
+   * is stored — see `./consent`. `validateConsent` judges the values.
+   */
+  consent: z39.strictObject({
+    analytics: z39.string().nullish(),
+    marketing: z39.string().nullish()
+  }).nullish()
 });
 var ingestBatchSchema = z39.strictObject({
   events: z39.array(ingestEventSchema).min(1).max(EVENT_INGEST_BATCH_MAX)
@@ -64540,6 +64635,15 @@ var shopifyStoreConnectionSchema = z50.enum(["connected", "needs_reconnect", "di
 var shopifyCatalogStateSchema = z50.enum(["starting", "importing", "ready", "failed"]);
 var shopifyStorefrontSchema = z50.enum(["online_store", "own"]);
 var shopifyAvailabilitySchema = z50.enum(["link_only", "not_for_sale"]);
+var shopifyBuyDestinationSchema = z50.enum(["checkout", "store_cart", "product_page"]);
+var shopifyBuyNoteSchema = z50.enum([
+  "subscription_only",
+  "subscription_optional",
+  "password_protected",
+  "own_storefront",
+  "details_pending"
+]);
+var shopifyUnreadablePartSchema = z50.enum(["metaobjects", "definitions", "languages", "policies"]);
 var shopifyStoreStateSchema = z50.object({
   name: z50.string(),
   connection: shopifyStoreConnectionSchema,
@@ -64564,13 +64668,26 @@ var shopifyProductsRequestSchema = z50.object({
   cursor: z50.string().optional(),
   full: flag.optional()
 });
+var SHOPIFY_MAX_BUY_QUANTITY = 99;
 var shopifyProductRequestSchema = z50.object({
   ref: z50.string().min(1).max(500),
   variantsCursor: z50.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: z50.string().min(1).max(200).optional(),
+  /** With `field`: the option (its `variantId`) whose field to return, when options share one. */
+  variant: z50.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: z50.coerce.number().int().min(1).max(SHOPIFY_MAX_BUY_QUANTITY).optional()
+});
+var shopifyCollectionsRequestSchema = z50.object({
+  search: z50.string().max(200).optional(),
+  /** Each collection's description, image and SEO. */
   full: flag.optional()
 });
-var shopifyCollectionsRequestSchema = z50.object({ search: z50.string().max(200).optional() });
 var shopifyStockRequestSchema = z50.object({
   collection: z50.string().min(1).max(500).optional(),
   limit: z50.coerce.number().int().min(1).max(200).optional(),
@@ -64602,8 +64719,35 @@ var shopifyStoreSummarySchema = z50.object({
     })
   ).optional(),
   productsUrl: z50.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: z50.literal(true).optional(),
+  /** The store's published languages, primary first. */
+  languages: z50.array(z50.object({ locale: z50.string(), name: z50.string(), primary: z50.boolean() })).optional(),
+  policies: z50.array(
+    z50.object({
+      type: z50.string(),
+      title: z50.string(),
+      url: z50.string().optional(),
+      // --full
+      text: z50.string().optional()
+    })
+  ).optional(),
+  /** Store content Baker can't read until the store owner accepts Baker's new permissions. */
+  unreadable: z50.array(shopifyUnreadablePartSchema).optional(),
   // --full
-  adminUrl: z50.string().optional()
+  adminUrl: z50.string().optional(),
+  brand: z50.object({
+    slogan: z50.string().optional(),
+    shortDescription: z50.string().optional(),
+    logoUrl: z50.string().optional(),
+    squareLogoUrl: z50.string().optional(),
+    coverImageUrl: z50.string().optional(),
+    colors: z50.array(
+      z50.object({ role: z50.string(), background: z50.string().optional(), foreground: z50.string().optional() })
+    )
+  }).optional()
 });
 var shopifyStoreResponseSchema = z50.object({
   store: shopifyStoreStateSchema,
@@ -64645,7 +64789,20 @@ var shopifyVariantSchema = z50.object({
   compareAtPrice: shopifyPriceSchema.optional(),
   stock: shopifyOptionStockSchema,
   quantity: z50.number().optional(),
+  /** The link for the page's buy button: never build a Shopify link by hand. Absent when the option can't be bought. */
+  buyUrl: z50.string().optional(),
+  buyUrlKind: shopifyBuyDestinationSchema.optional(),
+  /** Why there is no buy link. */
+  unavailable: z50.enum(["not_for_sale", "out_of_stock"]).optional(),
+  notes: z50.array(shopifyBuyNoteSchema).optional(),
   // --full
+  checkout: z50.string().optional(),
+  storeCart: z50.string().optional(),
+  productPage: z50.string().optional(),
+  weight: z50.string().optional(),
+  unitPrice: z50.string().optional(),
+  requiresShipping: z50.boolean().optional(),
+  taxable: z50.boolean().optional(),
   sku: z50.string().optional(),
   barcode: z50.string().optional(),
   selectedOptions: z50.array(z50.object({ name: z50.string(), value: z50.string() })).optional(),
@@ -64653,12 +64810,101 @@ var shopifyVariantSchema = z50.object({
   inventoryPolicy: z50.enum(["DENY", "CONTINUE"]).optional(),
   prices: z50.array(countryPriceSchema).optional()
 });
+var shopifyProductVideoSchema = z50.object({
+  videoId: z50.string(),
+  playbackId: z50.string(),
+  alt: z50.string().optional(),
+  /** Seconds. */
+  duration: z50.number().optional()
+});
+var shopifyFieldRefSchema = z50.object({
+  kind: z50.enum(["image", "file", "video", "product", "variant", "collection", "metaobject", "other"]),
+  id: z50.string(),
+  url: z50.string().optional(),
+  mimeType: z50.string().optional(),
+  alt: z50.string().optional(),
+  /** A video's preview image; its `url` is the video file itself. */
+  previewUrl: z50.string().optional(),
+  /** A product's or a collection's title, from Baker's copy. */
+  title: z50.string().optional(),
+  /** An image brought into the library: its imageId, to place like the product's photos. */
+  imageId: z50.string().optional(),
+  /** A custom content entry (a size chart, a care guide): its name and fields. */
+  entry: z50.object({
+    name: z50.string(),
+    fields: z50.array(z50.object({ name: z50.string(), text: z50.string(), truncated: z50.literal(true).optional() }))
+  }).optional()
+});
+var shopifyProductFieldSchema = z50.object({
+  name: z50.string(),
+  /** `namespace.key`: what `--field` takes when two fields share a name. */
+  key: z50.string(),
+  type: z50.string(),
+  owner: z50.enum(["product", "option"]),
+  variantId: z50.string().optional(),
+  text: z50.string(),
+  html: z50.string().optional(),
+  refs: z50.array(shopifyFieldRefSchema).optional(),
+  refsMore: z50.number().optional(),
+  /** The text or the list is longer than shown: `--field <key>` returns it whole. */
+  truncated: z50.literal(true).optional(),
+  /** The store owner hasn't let Baker read what this field points at yet. */
+  unreadable: z50.literal(true).optional()
+});
+var shopifyProductContentSchema = z50.object({
+  descriptionHtml: z50.string(),
+  descriptionTruncated: z50.literal(true).optional(),
+  category: z50.string().optional(),
+  giftCard: z50.literal(true).optional(),
+  fields: z50.array(shopifyProductFieldSchema),
+  rating: z50.object({ value: z50.number(), scaleMax: z50.number(), count: z50.number().optional() }).optional(),
+  /** Subscriptions the product can be bought with; `subscriptionOnly` when only by subscription. */
+  subscriptions: z50.array(
+    z50.object({ name: z50.string(), plans: z50.array(z50.object({ name: z50.string(), category: z50.string().optional() })) })
+  ).optional(),
+  subscriptionOnly: z50.literal(true).optional(),
+  /** YouTube or Vimeo videos and 3D models: links with their preview image. */
+  mediaLinks: z50.array(
+    z50.object({
+      kind: z50.enum(["external_video", "model_3d"]),
+      url: z50.string(),
+      embedUrl: z50.string().optional(),
+      previewUrl: z50.string().optional(),
+      alt: z50.string().optional()
+    })
+  ),
+  bundle: z50.array(z50.object({ productId: z50.string(), title: z50.string().optional(), quantity: z50.number() })).optional(),
+  combinedListing: z50.object({ role: z50.string(), parentProductId: z50.string().optional(), childProductIds: z50.array(z50.string()) }).optional(),
+  translations: z50.array(
+    z50.object({
+      locale: z50.string(),
+      title: z50.string().optional(),
+      description: z50.string().optional(),
+      seoTitle: z50.string().optional(),
+      seoDescription: z50.string().optional(),
+      options: z50.array(
+        z50.object({
+          name: z50.string(),
+          translatedName: z50.string().optional(),
+          values: z50.array(z50.object({ value: z50.string(), translated: z50.string().optional() }))
+        })
+      ),
+      truncated: z50.literal(true).optional()
+    })
+  ),
+  /** Content the store owner hasn't let Baker read yet. */
+  unreadable: z50.array(shopifyUnreadablePartSchema).optional(),
+  /** Baker hasn't read this product's details yet, or Shopify didn't send some of them. */
+  pending: z50.literal(true).optional(),
+  failure: z50.string().optional()
+});
 var shopifyProductDetailSchema = z50.object({
   productId: z50.string(),
   title: z50.string(),
   handle: z50.string(),
   /** The product's page in Baker — the link to share with the user. */
   url: z50.string(),
+  /** The product's page on the online store: to look at, never a buy button's link (that is each option's `buyUrl`). */
   storeUrl: z50.string().optional(),
   availability: shopifyAvailabilitySchema.optional(),
   status: shopifyProductStatusSchema.optional(),
@@ -64690,6 +64936,19 @@ var shopifyProductDetailSchema = z50.object({
   ).optional(),
   /** When Baker last read this product from the store. */
   observedAt: z50.string(),
+  /** What else Baker keeps about it, in a line: "formatted description, 2 videos, Size chart, 4.7★ from 120 reviews". */
+  contentSummary: z50.string().optional(),
+  /** Its Shopify videos in the video library: place one with `<Video playbackId=…/>`. */
+  videos: z50.array(shopifyProductVideoSchema),
+  videosAdding: z50.number(),
+  videosNotBrought: z50.number(),
+  /** Where the buy links send a shopper, and how many each puts in the cart. */
+  buyDestination: shopifyBuyDestinationSchema,
+  quantity: z50.number(),
+  /** --content (or --full): the whole of it. */
+  content: shopifyProductContentSchema.optional(),
+  /** --field: one custom field, whole. */
+  field: shopifyProductFieldSchema.optional(),
   // --full
   visibility: shopifyVisibilitySchema.optional(),
   seo: z50.object({ title: z50.string().optional(), description: z50.string().optional() }).optional(),
@@ -64706,7 +64965,11 @@ var shopifyCollectionRowSchema = z50.object({
   handle: z50.string(),
   /** Shopify's count at Baker's last read. */
   products: z50.number(),
-  onStore: z50.boolean().optional()
+  onStore: z50.boolean().optional(),
+  // --full
+  description: z50.string().optional(),
+  imageUrl: z50.string().optional(),
+  seo: z50.object({ title: z50.string().optional(), description: z50.string().optional() }).optional()
 });
 var shopifyCollectionsResponseSchema = z50.object({
   store: shopifyStoreStateSchema,
@@ -64848,8 +65111,58 @@ function stockHintsFor(product) {
   }
   return hints2;
 }
+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, but a buy link can only add it once \u2014 say so if the page promotes the subscription.",
+  own_storefront: "The store sells through its own storefront: buy links go straight to Shopify's checkout.",
+  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, which a buy link can't carry: its buy link is the product page, where the shopper picks the plan."
+};
+function buyHints(product) {
+  const hints2 = [];
+  if (product.variants.some((variant) => variant.buyUrl)) {
+    hints2.push(
+      `Use each option's \`buyUrl\` for the page's buy button \u2014 never build a Shopify link yourself (it follows the store's setting: ${product.buyDestination.replace("_", " ")}; \`--quantity <n>\` sets how many).`,
+      "Keep that `buyUrl` on the button: never `storeUrl` (a page to look at, not a buy link), and never drop or replace the buy button to get a page past its checks. The options to sell are `variants[]` alone \u2014 one buy button per option, each with its own `buyUrl`, never a size or colour picker made up from a size chart or other details. When the shopper must choose on the store, link the option's `productPage` (from `--full`)."
+    );
+  }
+  const notes = new Set(product.variants.flatMap((variant) => variant.notes ?? []));
+  for (const note of notes) hints2.push(BUY_NOTES[note]);
+  return hints2;
+}
+function contentHints(product) {
+  const hints2 = [];
+  const [video] = product.videos;
+  if (video) {
+    hints2.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) {
+    hints2.push(
+      `${product.videosNotBrought} more videos stay in Shopify (Baker keeps up to 5 per product); use the ones listed.`
+    );
+  }
+  if (product.videosAdding > 0) hints2.push(`${product.videosAdding} videos are still being added.`);
+  if (product.contentSummary && !product.content) {
+    hints2.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}` : "";
+    hints2.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)) {
+    hints2.push(
+      "Some content isn't readable yet: ask the user to open Baker in their Shopify admin and accept the new permissions."
+    );
+  }
+  return hints2;
+}
 function productHints(product, store) {
-  const hints2 = [...photoHints(product), ...stockHintsFor(product)];
+  const hints2 = [...photoHints(product), ...stockHintsFor(product), ...buyHints(product), ...contentHints(product)];
   if (product.availability === "not_for_sale") {
     hints2.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.`
@@ -64899,6 +65212,16 @@ function stockHints(answer, limit) {
 }
 function storeHints(summary) {
   const hints2 = ["Share the Products page link (productsUrl) when the user wants to browse the catalog."];
+  if (summary.unreadable?.length) {
+    hints2.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) {
+    hints2.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,
@@ -64972,8 +65295,13 @@ var fullArg = {
 };
 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), 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.',
-  args: { full: { ...fullArg, description: "Add the store's products page in Shopify admin and every country" } }
+  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.',
+  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",
@@ -65002,7 +65330,7 @@ registerSchema({
 });
 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 and stock, prices by country, the options out of stock, its collections, and its photos' library imageIds to place on a landing (`baker images download <imageIds> --out src/pages/<page>/_images/`) or pass to a creative. `--out-of-stock` lists only the options out of stock.",
+  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` (the link for a page's buy button, one per option \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": {
@@ -65016,16 +65344,40 @@ registerSchema({
       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: "Whole description, SEO, category, admin link, 250 options per page with SKU and prices by country"
+      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.",
-  args: { search: { type: "string", description: "Words in the collection's title or handle", required: false } }
+  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",
@@ -65102,7 +65454,7 @@ var productsCommand = defineCommand209({
 var productCommand = defineCommand209({
   meta: {
     name: "product",
-    description: "One product: options, prices by country, stock, photo imageIds. Accepts an id, handle or link. Example: baker shopify product the-complete-snowboard"
+    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 },
@@ -65112,6 +65464,23 @@ var productCommand = defineCommand209({
       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: args5 }) => {
@@ -65129,6 +65498,10 @@ var productCommand = defineCommand209({
           ref: args5.ref,
           variantsCursor: args5["variants-cursor"],
           outOfStock: args5["out-of-stock"],
+          content: args5.content,
+          field: args5.field,
+          variant: args5.variant,
+          quantity: args5.quantity,
           full: args5.full
         })
       );
@@ -65144,14 +65517,17 @@ var productCommand = defineCommand209({
 var collectionsCommand = defineCommand209({
   meta: {
     name: "collections",
-    description: "The store's collections, with the handles --collection takes. Example: baker shopify 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 }
   },
-  args: { search: { type: "string", description: "Words in the title or handle", required: false } },
   run: async ({ args: args5 }) => {
     try {
       const answer = await apiGet(
         "/api/shopify/collections",
-        params({ search: args5.search })
+        params({ search: args5.search, full: args5.full })
       );
       emit2(
         answer.collections,
@@ -65197,13 +65573,20 @@ 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, prices by country, photo imageIds
+  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
 
 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" />.
+A page's buy button uses the option's buyUrl, one button per option \u2014 never build a Shopify link
+yourself, and 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`