shop-cli 0.1.1

package/dist/cli/verbs/products.js

@@ -0,0 +1,2309 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var products_exports = {};
+__export(products_exports, {
+  runProducts: () => runProducts
+});
+module.exports = __toCommonJS(products_exports);
+var import_errors = require("../errors");
+var import_gid = require("../gid");
+var import_render = require("../help/render");
+var import_input = require("../input");
+var import_output = require("../output");
+var import_computedFields = require("../output/computedFields");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_userErrors = require("../userErrors");
+var import_stagedUploads = require("../workflows/files/stagedUploads");
+var import_waitForReady = require("../workflows/files/waitForReady");
+var import_stdinFile = require("../workflows/files/stdinFile");
+var import_metafieldsUpsert = require("../workflows/products/metafieldsUpsert");
+var import_publishablePublish = require("../workflows/products/publishablePublish");
+var import_resolvePublicationId = require("../workflows/publications/resolvePublicationId");
+var import_shared = require("./_shared");
+const requireProductIdForSubverb = (args) => {
+  if (args.id !== void 0) {
+    throw new import_errors.CliError("Unknown flag --id, did you mean --product-id?", 2);
+  }
+  return (0, import_shared.requireGidFlag)(args["product-id"], "--product-id", "Product");
+};
+const requireProductIdForRootVerb = (args) => {
+  const rawId = args.id;
+  const rawProductId = args["product-id"];
+  const hasId = typeof rawId === "string" && rawId.length > 0;
+  const hasProductId = typeof rawProductId === "string" && rawProductId.length > 0;
+  if (!hasId && !hasProductId) {
+    throw new import_errors.CliError("Missing --id", 2);
+  }
+  if (hasId && hasProductId) {
+    const a = (0, import_gid.coerceGid)(rawId, "Product");
+    const b = (0, import_gid.coerceGid)(rawProductId, "Product");
+    if (a !== b) throw new import_errors.CliError("Conflicting --id and --product-id", 2);
+    return a;
+  }
+  if (hasProductId) {
+    return (0, import_shared.requireGidFlag)(rawProductId, "--product-id", "Product");
+  }
+  return (0, import_shared.requireId)(rawId, "Product");
+};
+const productMediaSummarySelection = {
+  id: true,
+  mediaContentType: true,
+  status: true,
+  alt: true,
+  preview: { status: true, image: { url: true } }
+};
+const productMediaSelection = {
+  mediaErrors: { code: true, message: true },
+  mediaWarnings: { code: true, message: true },
+  ...productMediaSummarySelection
+};
+const productSummarySelection = {
+  id: true,
+  title: true,
+  handle: true,
+  status: true,
+  updatedAt: true
+};
+const productSummarySelectionForGet = {
+  ...productSummarySelection,
+  ...import_computedFields.computedPublicationsSelection
+};
+const productFullSelection = {
+  ...productSummarySelection,
+  createdAt: true,
+  tags: true
+};
+const productFullSelectionForGet = {
+  ...productFullSelection,
+  ...import_computedFields.computedPublicationsSelection
+};
+const productTagsSummarySelection = {
+  ...productSummarySelection,
+  tags: true
+};
+const productOptionSelection = {
+  id: true,
+  name: true,
+  position: true,
+  values: true
+};
+const productOptionListSummarySelection = {
+  id: true,
+  name: true,
+  position: true,
+  values: true
+};
+const productOptionListFullSelection = {
+  ...productOptionListSummarySelection,
+  optionValues: { id: true, name: true, hasVariants: true }
+};
+const getProductOptionListSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return productOptionListFullSelection;
+  if (view === "raw") return {};
+  return productOptionListSummarySelection;
+};
+const productOptionsSummarySelection = {
+  ...productSummarySelection,
+  options: {
+    __args: { first: 100 },
+    ...productOptionSelection
+  }
+};
+const productOptionsFullSelection = {
+  ...productFullSelection,
+  options: {
+    __args: { first: 100 },
+    ...productOptionSelection
+  }
+};
+const productVariantSummarySelection = {
+  id: true,
+  displayName: true,
+  sku: true,
+  price: true,
+  availableForSale: true
+};
+const productVariantFullSelection = {
+  ...productVariantSummarySelection,
+  barcode: true,
+  compareAtPrice: true,
+  inventoryQuantity: true,
+  product: { id: true, title: true },
+  inventoryItem: { id: true }
+};
+const getProductVariantSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return productVariantFullSelection;
+  if (view === "raw") return {};
+  return productVariantSummarySelection;
+};
+const getProductSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return productFullSelection;
+  if (view === "raw") return {};
+  return productSummarySelection;
+};
+const getProductSelectionForTags = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return productFullSelection;
+  if (view === "raw") return {};
+  return productTagsSummarySelection;
+};
+const getProductSelectionForOptions = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return productOptionsFullSelection;
+  if (view === "raw") return {};
+  return productOptionsSummarySelection;
+};
+const getProductSelectionForGet = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return productFullSelectionForGet;
+  if (view === "raw") return {};
+  return productSummarySelectionForGet;
+};
+const getProductMediaSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "summary") return productMediaSummarySelection;
+  return productMediaSelection;
+};
+const parseTags = (tags) => {
+  if (!tags) throw new import_errors.CliError("Missing --tags", 2);
+  const parts = tags.split(",").map((t) => t.trim()).filter(Boolean);
+  if (parts.length === 0) throw new import_errors.CliError("--tags must include at least one tag", 2);
+  return parts;
+};
+const normalizeMediaContentType = (value) => {
+  if (!value) return "IMAGE";
+  const v = value.toUpperCase();
+  if (v === "IMAGE" || v === "VIDEO" || v === "MODEL_3D" || v === "EXTERNAL_VIDEO") return v;
+  throw new import_errors.CliError("--media-content-type/--media-type must be IMAGE|VIDEO|MODEL_3D|EXTERNAL_VIDEO", 2);
+};
+const parsePositiveIntFlag = ({
+  value,
+  flag
+}) => {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") throw new import_errors.CliError(`Invalid ${flag} value`, 2);
+  const trimmed = value.trim();
+  if (!trimmed) throw new import_errors.CliError(`Invalid ${flag} value`, 2);
+  const n = Number(trimmed);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+    throw new import_errors.CliError(`${flag} must be a positive integer`, 2);
+  }
+  return n;
+};
+const getTopProductMediaIds = async ({
+  ctx,
+  productId,
+  first = 250
+}) => {
+  const result = await (0, import_router.runQuery)(ctx, {
+    product: {
+      __args: { id: productId },
+      media: {
+        __args: { first, reverse: true, sortKey: "POSITION" },
+        nodes: { id: true }
+      }
+    }
+  });
+  if (result === void 0) return [];
+  const nodes = result.product?.media?.nodes ?? [];
+  return nodes.map((n) => typeof n?.id === "string" ? n.id : void 0).filter((id) => typeof id === "string" && id.trim() !== "");
+};
+const normalizeMediaId = (value) => {
+  const raw = value.trim();
+  if (!raw) throw new import_errors.CliError("Media ID cannot be empty", 2);
+  if (raw.startsWith("gid://")) return raw;
+  throw new import_errors.CliError(
+    `Numeric media ID "${raw}" is ambiguous. Use the full GID from "shop products media list" (e.g. gid://shopify/MediaImage/${raw})`,
+    2
+  );
+};
+const mediaTypeToStagedResource = (mediaType) => {
+  if (mediaType === "IMAGE") return "IMAGE";
+  if (mediaType === "VIDEO") return "VIDEO";
+  if (mediaType === "MODEL_3D") return "MODEL_3D";
+  throw new import_errors.CliError("--media-type EXTERNAL_VIDEO cannot be used with --file uploads", 2);
+};
+const stagedResourceToMediaType = (resource) => {
+  if (resource === "IMAGE") return "IMAGE";
+  if (resource === "VIDEO") return "VIDEO";
+  if (resource === "MODEL_3D") return "MODEL_3D";
+  throw new import_errors.CliError("Only IMAGE|VIDEO|MODEL_3D can be uploaded as product media", 2);
+};
+const parseVariantOptionValues = (value) => {
+  if (value === void 0 || value === null) return [];
+  const raw = Array.isArray(value) ? value : [value];
+  const optionValues = [];
+  for (const entry of raw) {
+    if (typeof entry !== "string") throw new import_errors.CliError("--variant-option must be a string", 2);
+    const trimmed = entry.trim();
+    if (!trimmed) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0 || eq === trimmed.length - 1) {
+      throw new import_errors.CliError(`--variant-option must be in the form OptionName=Value. Got: ${entry}`, 2);
+    }
+    const optionName = trimmed.slice(0, eq).trim();
+    const name = trimmed.slice(eq + 1).trim();
+    if (!optionName || !name) {
+      throw new import_errors.CliError(`--variant-option must be in the form OptionName=Value. Got: ${entry}`, 2);
+    }
+    optionValues.push({ optionName, name });
+  }
+  return optionValues;
+};
+const parseRepeatableStrings = (value, flag, { allowEmpty = false } = {}) => {
+  if (value === void 0 || value === null) {
+    if (allowEmpty) return [];
+    throw new import_errors.CliError(`Missing ${flag}`, 2);
+  }
+  const raw = Array.isArray(value) ? value : [value];
+  const out = [];
+  for (const entry of raw) {
+    if (typeof entry !== "string") throw new import_errors.CliError(`${flag} must be a string (repeatable)`, 2);
+    const trimmed = entry.trim();
+    if (!trimmed) throw new import_errors.CliError(`${flag} cannot be empty`, 2);
+    out.push(trimmed);
+  }
+  if (out.length === 0) {
+    if (allowEmpty) return [];
+    throw new import_errors.CliError(`Missing ${flag}`, 2);
+  }
+  return out;
+};
+const parseOptionSpec = (value, flag) => {
+  const trimmed = value.trim();
+  const eq = trimmed.indexOf("=");
+  if (eq <= 0 || eq === trimmed.length - 1) {
+    throw new import_errors.CliError(`${flag} must be in the form Name=Value1,Value2,... Got: ${value}`, 2);
+  }
+  const name = trimmed.slice(0, eq).trim();
+  const valuesRaw = trimmed.slice(eq + 1).trim();
+  if (!name || !valuesRaw) {
+    throw new import_errors.CliError(`${flag} must be in the form Name=Value1,Value2,... Got: ${value}`, 2);
+  }
+  const valueNames = valuesRaw.split(",").map((v) => v.trim()).filter(Boolean);
+  if (valueNames.length === 0) {
+    throw new import_errors.CliError(`${flag} must include at least one value. Got: ${value}`, 2);
+  }
+  return {
+    name,
+    values: valueNames.map((v) => ({ name: v }))
+  };
+};
+const parseFromTo = (value, flag) => {
+  const trimmed = value.trim();
+  const eq = trimmed.indexOf("=");
+  if (eq <= 0 || eq === trimmed.length - 1) {
+    throw new import_errors.CliError(`${flag} must be in the form From=To. Got: ${value}`, 2);
+  }
+  const from = trimmed.slice(0, eq).trim();
+  const to = trimmed.slice(eq + 1).trim();
+  if (!from || !to) {
+    throw new import_errors.CliError(`${flag} must be in the form From=To. Got: ${value}`, 2);
+  }
+  return { from, to };
+};
+const looksLikeGidOrNumericId = (value) => /^gid:\/\//i.test(value) || /^\d+$/.test(value);
+const normalizeProductOptionCreateVariantStrategy = (value) => {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") throw new import_errors.CliError("--variant-strategy must be a string", 2);
+  const v = value.trim().toUpperCase();
+  if (v === "LEAVE_AS_IS" || v === "CREATE") return v;
+  throw new import_errors.CliError("--variant-strategy must be LEAVE_AS_IS|CREATE", 2);
+};
+const normalizeProductOptionUpdateVariantStrategy = (value) => {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") throw new import_errors.CliError("--variant-strategy must be a string", 2);
+  const v = value.trim().toUpperCase();
+  if (v === "LEAVE_AS_IS" || v === "MANAGE") return v;
+  throw new import_errors.CliError("--variant-strategy must be LEAVE_AS_IS|MANAGE", 2);
+};
+const normalizeProductOptionDeleteStrategy = (value) => {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") throw new import_errors.CliError("--strategy must be a string", 2);
+  const v = value.trim().toUpperCase();
+  if (v === "DEFAULT" || v === "NON_DESTRUCTIVE" || v === "POSITION") return v;
+  throw new import_errors.CliError("--strategy must be DEFAULT|NON_DESTRUCTIVE|POSITION", 2);
+};
+const productOptionResolveSelection = {
+  id: true,
+  name: true,
+  position: true,
+  values: true,
+  optionValues: { id: true, name: true }
+};
+const fetchProductOptionsForResolution = async ({ ctx, productId }) => {
+  const result = await (0, import_router.runQuery)(ctx, {
+    product: { __args: { id: productId }, options: productOptionResolveSelection }
+  });
+  if (result === void 0) return [];
+  return result.product?.options ?? [];
+};
+const resolveSingleOptionByName = (options, name) => {
+  const matches = options.filter((o) => typeof o?.name === "string" && o.name === name);
+  if (matches.length === 0) return void 0;
+  if (matches.length > 1) {
+    throw new import_errors.CliError(`Multiple product options named "${name}" exist. Use --option-id instead.`, 2);
+  }
+  return matches[0];
+};
+const parseInventoryPolicy = (value) => {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") throw new import_errors.CliError("--inventory-policy must be a string", 2);
+  const normalized = value.trim().toUpperCase();
+  if (normalized === "DENY" || normalized === "CONTINUE") return normalized;
+  throw new import_errors.CliError(`--inventory-policy must be DENY|CONTINUE. Got: ${value}`, 2);
+};
+const runProducts = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  const groupHelpVerbs = /* @__PURE__ */ new Set(["variants", "options", "media"]);
+  if (groupHelpVerbs.has(verb)) {
+    const groupHelp = (0, import_render.renderVerbGroupHelp)("products", verb);
+    if (groupHelp) console.log(groupHelp);
+    if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) return;
+    throw new import_errors.CliError(`
+Missing <verb> for "products ${verb}"`, 2);
+  }
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop products <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|count|update|delete|duplicate|set-status|archive|unarchive",
+        "  by-handle|by-identifier|operation|duplicate-job",
+        "  tags|types|vendors",
+        "  change-status|set",
+        "  join-selling-plan-groups|leave-selling-plan-groups",
+        "  options list|options create|options update|options delete|options reorder",
+        "  variants list|variants create|variants update|variants delete|variants reorder",
+        "  combined-listing-update",
+        "  add-tags|remove-tags|set-price",
+        "  publish|unpublish|publish-all",
+        "  bundle-create|bundle-update",
+        "  metafields upsert",
+        "  media add|media upload|media list|media remove|media reorder|media update",
+        "",
+        "Common output flags:",
+        "  --view summary|ids|full|raw",
+        "  --select <path>        (repeatable; dot paths; adds to base view selection)",
+        "  --selection <graphql>  (selection override; can be @file.gql)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "variants list") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "product-id": { type: "string" } }
+    });
+    if (args.query) {
+      throw new import_errors.CliError(
+        "--query is not supported for `shop products variants list` (product-scoped variants). Use `shop product-variants list --query ...` for global variant search.",
+        2
+      );
+    }
+    const productId = requireProductIdForSubverb(args);
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      typeName: "ProductVariant",
+      view: ctx.view,
+      baseSelection: getProductVariantSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      product: {
+        __args: { id: productId },
+        variants: {
+          __args: { first, after, reverse, sortKey },
+          pageInfo: { hasNextPage: true, endCursor: true },
+          nodes: nodeSelection
+        }
+      }
+    });
+    if (result === void 0) return;
+    const connection = result.product?.variants;
+    if (!connection) throw new import_errors.CliError("Product not found", 2);
+    (0, import_output.printConnection)({
+      connection,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: {
+        base: "shop products variants list",
+        first,
+        sort: typeof sortKey === "string" ? sortKey : void 0,
+        reverse: reverse === true,
+        extraFlags: [{ flag: "--product-id", value: productId }]
+      }
+    });
+    return;
+  }
+  if (verb === "variants create") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "variant-option": { type: "string", multiple: true },
+        sku: { type: "string" },
+        barcode: { type: "string" },
+        price: { type: "string" },
+        "compare-at-price": { type: "string" },
+        "inventory-policy": { type: "string" },
+        strategy: { type: "string" }
+      }
+    });
+    const productId = requireProductIdForSubverb(args);
+    const optionValues = parseVariantOptionValues(args["variant-option"]);
+    if (optionValues.length === 0) {
+      throw new import_errors.CliError("Missing --variant-option OptionName=Value (repeatable)", 2);
+    }
+    const sku = args.sku;
+    const barcode = args.barcode;
+    const price = args.price;
+    const compareAtPrice = args["compare-at-price"];
+    const inventoryPolicy = parseInventoryPolicy(args["inventory-policy"]);
+    const strategy = args.strategy;
+    if (strategy && !["DEFAULT", "PRESERVE_STANDALONE_VARIANT", "REMOVE_STANDALONE_VARIANT"].includes(
+      strategy.trim().toUpperCase()
+    )) {
+      throw new import_errors.CliError(
+        `--strategy must be DEFAULT|PRESERVE_STANDALONE_VARIANT|REMOVE_STANDALONE_VARIANT. Got: ${strategy}`,
+        2
+      );
+    }
+    const normalizedStrategy = strategy ? strategy.trim().toUpperCase() : void 0;
+    const variantSelection = (0, import_select.resolveSelection)({
+      typeName: "ProductVariant",
+      view: ctx.view,
+      baseSelection: getProductVariantSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const variantInput = {
+      optionValues,
+      ...barcode ? { barcode } : {},
+      ...price ? { price } : {},
+      ...compareAtPrice ? { compareAtPrice } : {},
+      ...inventoryPolicy ? { inventoryPolicy } : {},
+      ...sku ? { inventoryItem: { sku } } : {}
+    };
+    const result = await (0, import_router.runMutation)(ctx, {
+      productVariantsBulkCreate: {
+        __args: {
+          productId,
+          variants: [variantInput],
+          ...normalizedStrategy ? { strategy: normalizedStrategy } : {}
+        },
+        userErrors: { field: true, message: true },
+        productVariants: variantSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.productVariantsBulkCreate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    const created = result.productVariantsBulkCreate?.productVariants?.[0];
+    (0, import_output.printNode)({ node: created, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "variants update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "variant-id": { type: "string" },
+        "variant-option": { type: "string", multiple: true },
+        sku: { type: "string" },
+        barcode: { type: "string" },
+        price: { type: "string" },
+        "compare-at-price": { type: "string" },
+        "inventory-policy": { type: "string" },
+        "allow-partial-updates": { type: "boolean" }
+      }
+    });
+    if (args.id !== void 0) {
+      if (args["product-id"] !== void 0) {
+        throw new import_errors.CliError("Unknown flag --id, did you mean --variant-id?", 2);
+      }
+      ;
+      args["product-id"] = args.id;
+      delete args.id;
+    }
+    const productId = requireProductIdForSubverb(args);
+    const variantId = (0, import_shared.requireId)(args["variant-id"], "ProductVariant", "--variant-id");
+    const optionValues = parseVariantOptionValues(args["variant-option"]);
+    const sku = args.sku;
+    const barcode = args.barcode;
+    const price = args.price;
+    const compareAtPrice = args["compare-at-price"];
+    const inventoryPolicy = parseInventoryPolicy(args["inventory-policy"]);
+    const allowPartialUpdates = args["allow-partial-updates"] === true;
+    const variantSelection = (0, import_select.resolveSelection)({
+      typeName: "ProductVariant",
+      view: ctx.view,
+      baseSelection: getProductVariantSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const variantInput = {
+      id: variantId,
+      ...optionValues.length ? { optionValues } : {},
+      ...barcode ? { barcode } : {},
+      ...price ? { price } : {},
+      ...compareAtPrice ? { compareAtPrice } : {},
+      ...inventoryPolicy ? { inventoryPolicy } : {},
+      ...sku ? { inventoryItem: { sku } } : {}
+    };
+    const result = await (0, import_router.runMutation)(ctx, {
+      productVariantsBulkUpdate: {
+        __args: {
+          productId,
+          allowPartialUpdates,
+          variants: [variantInput]
+        },
+        userErrors: { field: true, message: true },
+        productVariants: variantSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.productVariantsBulkUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    const updated = result.productVariantsBulkUpdate?.productVariants?.[0];
+    (0, import_output.printNode)({ node: updated, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "variants delete") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "variant-id": { type: "string" }
+      }
+    });
+    const productId = requireProductIdForSubverb(args);
+    const variantId = (0, import_shared.requireId)(args["variant-id"], "ProductVariant", "--variant-id");
+    const result = await (0, import_router.runMutation)(ctx, {
+      productVariantsBulkDelete: {
+        __args: { productId, variantsIds: [variantId] },
+        product: { id: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.productVariantsBulkDelete,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    const verify = await (0, import_router.runQuery)(ctx, {
+      nodes: {
+        __args: { ids: [variantId] },
+        id: true
+      }
+    });
+    if (verify === void 0) return;
+    const stillThere = verify.nodes?.[0] !== null && verify.nodes?.[0] !== void 0;
+    const deletedVariantId = stillThere ? void 0 : variantId;
+    if (ctx.quiet) return (0, import_output.printIds)([deletedVariantId]);
+    (0, import_output.printJson)({ productId, deletedVariantId }, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "variants reorder") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "variant-id": { type: "string" },
+        position: { type: "string" }
+      }
+    });
+    const productId = requireProductIdForSubverb(args);
+    const variantId = (0, import_shared.requireId)(args["variant-id"], "ProductVariant", "--variant-id");
+    const position = (0, import_shared.parseIntFlag)("--position", args.position);
+    if (position <= 0) throw new import_errors.CliError("--position must be a positive integer (1-based)", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      productVariantsBulkReorder: {
+        __args: { productId, positions: [{ id: variantId, position }] },
+        product: { id: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.productVariantsBulkReorder,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return (0, import_output.printIds)([variantId]);
+    (0, import_output.printJson)({ productId, variantId, position }, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "by-handle") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { handle: { type: "string" } } });
+    const handle = args.handle;
+    if (!handle) throw new import_errors.CliError("Missing --handle", 2);
+    const selectValues = Array.isArray(args.select) ? args.select : args.select ? [args.select] : [];
+    const selectionOverride = typeof args.selection === "string" && args.selection.length > 0;
+    const select = !selectionOverride && ctx.view !== "raw" && ctx.view !== "ids" ? Array.from(/* @__PURE__ */ new Set([...selectValues, "resourcePublicationsV2.nodes.publication.name"])) : args.select;
+    const includeValues = Array.isArray(args.include) ? args.include : args.include ? [args.include] : [];
+    const include = ctx.view === "all" ? Array.from(/* @__PURE__ */ new Set([...includeValues, "resourcePublicationsV2"])) : args.include;
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelectionForGet(ctx.view),
+      select,
+      selection: args.selection,
+      include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runQuery)(ctx, { productByHandle: { __args: { handle }, ...selection } });
+    if (result === void 0) return;
+    const wantsResourcePublicationsV2 = Array.isArray(args.select) && args.select.some((p) => typeof p === "string" && p.startsWith("resourcePublicationsV2"));
+    const wantsResourcePublicationsV2ViaSelection = typeof args.selection === "string" && args.selection.includes("resourcePublicationsV2");
+    const stripResourcePublicationsV2 = !(wantsResourcePublicationsV2 || wantsResourcePublicationsV2ViaSelection);
+    const withComputed = (0, import_computedFields.applyComputedFieldsToNode)(result.productByHandle, {
+      view: ctx.view,
+      stripResourcePublicationsV2
+    });
+    (0, import_output.printNode)({ node: withComputed, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "by-identifier") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { identifier: { type: "string" } } });
+    const identifier = (0, import_shared.parseJsonArg)(args.identifier, "--identifier");
+    const selectValues = Array.isArray(args.select) ? args.select : args.select ? [args.select] : [];
+    const selectionOverride = typeof args.selection === "string" && args.selection.length > 0;
+    const select = !selectionOverride && ctx.view !== "raw" && ctx.view !== "ids" ? Array.from(/* @__PURE__ */ new Set([...selectValues, "resourcePublicationsV2.nodes.publication.name"])) : args.select;
+    const includeValues = Array.isArray(args.include) ? args.include : args.include ? [args.include] : [];
+    const include = ctx.view === "all" ? Array.from(/* @__PURE__ */ new Set([...includeValues, "resourcePublicationsV2"])) : args.include;
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelectionForGet(ctx.view),
+      select,
+      selection: args.selection,
+      include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runQuery)(ctx, { productByIdentifier: { __args: { identifier }, ...selection } });
+    if (result === void 0) return;
+    const wantsResourcePublicationsV2 = Array.isArray(args.select) && args.select.some((p) => typeof p === "string" && p.startsWith("resourcePublicationsV2"));
+    const wantsResourcePublicationsV2ViaSelection = typeof args.selection === "string" && args.selection.includes("resourcePublicationsV2");
+    const stripResourcePublicationsV2 = !(wantsResourcePublicationsV2 || wantsResourcePublicationsV2ViaSelection);
+    const withComputed = (0, import_computedFields.applyComputedFieldsToNode)(result.productByIdentifier, {
+      view: ctx.view,
+      stripResourcePublicationsV2
+    });
+    (0, import_output.printNode)({ node: withComputed, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "duplicate-job") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = args.id;
+    if (typeof id !== "string" || !id) throw new import_errors.CliError("Missing --id", 2);
+    const selection = (0, import_select.resolveSelection)({
+      typeName: "ProductDuplicateJob",
+      view: ctx.view,
+      baseSelection: { id: true, done: true },
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { productDuplicateJob: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.productDuplicateJob, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "operation") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = args.id;
+    if (typeof id !== "string" || !id) throw new import_errors.CliError("Missing --id", 2);
+    const getProductOperationSelection = (view) => {
+      if (view === "raw") return {};
+      if (view === "ids") {
+        return {
+          __typename: true,
+          on_ProductBundleOperation: { id: true },
+          on_ProductDeleteOperation: { id: true },
+          on_ProductDuplicateOperation: { id: true, newProduct: { id: true }, product: { id: true } },
+          on_ProductSetOperation: { id: true, product: { id: true } }
+        };
+      }
+      return {
+        __typename: true,
+        status: true,
+        product: { id: true, title: true, handle: true, status: true },
+        on_ProductBundleOperation: {
+          id: true,
+          status: true,
+          product: { id: true, title: true },
+          userErrors: { field: true, message: true }
+        },
+        on_ProductDeleteOperation: {
+          id: true,
+          status: true,
+          product: { id: true, title: true },
+          userErrors: { field: true, message: true }
+        },
+        on_ProductDuplicateOperation: {
+          id: true,
+          status: true,
+          product: { id: true, title: true },
+          newProduct: { id: true, title: true },
+          userErrors: { field: true, message: true }
+        },
+        on_ProductSetOperation: {
+          id: true,
+          status: true,
+          product: { id: true, title: true },
+          userErrors: { code: true, field: true, message: true }
+        }
+      };
+    };
+    const selection = (0, import_select.resolveSelection)({
+      typeName: "ProductOperation",
+      view: ctx.view,
+      baseSelection: getProductOperationSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { productOperation: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.productOperation, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "tags" || verb === "types" || verb === "vendors") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const field = verb === "tags" ? "productTags" : verb === "types" ? "productTypes" : "productVendors";
+    const result = await (0, import_router.runQuery)(ctx, {
+      [field]: {
+        __args: { first, after, reverse },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: true
+      }
+    });
+    if (result === void 0) return;
+    const connection = result[field];
+    if (ctx.quiet) {
+      for (const value of connection?.nodes ?? []) {
+        if (typeof value === "string" && value) process.stdout.write(`${value}
+`);
+      }
+      return;
+    }
+    (0, import_output.printConnection)({
+      connection,
+      format: ctx.format,
+      quiet: false,
+      nextPageArgs: { base: `shop products ${verb}`, first, reverse: reverse === true }
+    });
+    return;
+  }
+  if (verb === "change-status") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const productId = requireProductIdForRootVerb(args);
+    const status = args.status;
+    if (!status) throw new import_errors.CliError("Missing --status (ACTIVE|DRAFT|ARCHIVED)", 2);
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productChangeStatus: {
+        __args: { productId, status },
+        product: selection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productChangeStatus, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: result.productChangeStatus?.product, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "set") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        identifier: { type: "string" },
+        synchronous: { type: "string" }
+      }
+    });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const identifier = args.identifier ? (0, import_shared.parseJsonArg)(args.identifier, "--identifier") : void 0;
+    const synchronousRaw = args.synchronous;
+    const synchronous = (() => {
+      if (synchronousRaw === void 0 || synchronousRaw === null || synchronousRaw === "") return void 0;
+      const v = String(synchronousRaw).toLowerCase();
+      if (v === "true" || v === "1") return true;
+      if (v === "false" || v === "0") return false;
+      throw new import_errors.CliError("--synchronous must be true|false", 2);
+    })();
+    const result = await (0, import_router.runMutation)(ctx, {
+      productSet: {
+        __args: {
+          input: built.input,
+          ...identifier !== void 0 ? { identifier } : {},
+          ...synchronous !== void 0 ? { synchronous } : {}
+        },
+        product: productSummarySelection,
+        productSetOperation: {
+          id: true,
+          status: true,
+          product: productSummarySelection,
+          userErrors: { code: true, field: true, message: true }
+        },
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productSet, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      const pid = result.productSet?.product?.id;
+      const opId = result.productSet?.productSetOperation?.id;
+      return console.log(pid ?? opId ?? "");
+    }
+    (0, import_output.printJson)(result.productSet, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "join-selling-plan-groups" || verb === "leave-selling-plan-groups") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "product-id": { type: "string" }, "group-ids": { type: "string", multiple: true } }
+    });
+    const id = requireProductIdForRootVerb(args);
+    const sellingPlanGroupIds = (0, import_shared.parseIds)(args["group-ids"], "SellingPlanGroup");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const mutation = verb === "join-selling-plan-groups" ? "productJoinSellingPlanGroups" : "productLeaveSellingPlanGroups";
+    const result = await (0, import_router.runMutation)(ctx, {
+      [mutation]: {
+        __args: { id, sellingPlanGroupIds },
+        product: selection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    const payload = result[mutation];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: payload?.product, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "options list") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const productId = requireProductIdForSubverb(args);
+    const selection = (0, import_select.resolveSelection)({
+      typeName: "ProductOption",
+      view: ctx.view,
+      baseSelection: getProductOptionListSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      product: {
+        __args: { id: productId },
+        options: selection
+      }
+    });
+    if (result === void 0) return;
+    const options = result.product?.options ?? [];
+    (0, import_output.printConnection)({
+      connection: { nodes: options, pageInfo: void 0 },
+      format: ctx.format,
+      quiet: ctx.quiet
+    });
+    return;
+  }
+  if (verb === "options create") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        option: { type: "string", multiple: true },
+        "options-json": { type: "string" },
+        "variant-strategy": { type: "string" }
+      }
+    });
+    const productId = requireProductIdForSubverb(args);
+    const optionSpecs = parseRepeatableStrings(args.option, "--option", { allowEmpty: true });
+    const optionsJsonRaw = args["options-json"];
+    if (optionSpecs.length > 0 && optionsJsonRaw) {
+      throw new import_errors.CliError("Do not pass both --option and --options-json", 2);
+    }
+    const options = optionsJsonRaw !== void 0 ? (0, import_shared.parseJsonArg)(optionsJsonRaw, "--options-json") : optionSpecs.map((s) => parseOptionSpec(s, "--option"));
+    if (!Array.isArray(options) || options.length === 0) {
+      throw new import_errors.CliError("Missing options: pass one or more --option entries, or --options-json", 2);
+    }
+    const variantStrategy = normalizeProductOptionCreateVariantStrategy(args["variant-strategy"]);
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelectionForOptions(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productOptionsCreate: {
+        __args: { productId, options, ...variantStrategy ? { variantStrategy } : {} },
+        product: selection,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productOptionsCreate, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: result.productOptionsCreate?.product, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "options update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "option-id": { type: "string" },
+        name: { type: "string" },
+        position: { type: "string" },
+        "add-value": { type: "string", multiple: true },
+        "delete-value": { type: "string", multiple: true },
+        "rename-value": { type: "string", multiple: true },
+        "delete-value-id": { type: "string", multiple: true },
+        "rename-value-id": { type: "string", multiple: true },
+        "option-json": { type: "string" },
+        "add-values-json": { type: "string" },
+        "delete-value-ids-json": { type: "string" },
+        "update-values-json": { type: "string" },
+        "variant-strategy": { type: "string" }
+      }
+    });
+    const productId = requireProductIdForSubverb(args);
+    const optionIdRaw = args["option-id"];
+    if (!optionIdRaw) throw new import_errors.CliError("Missing --option-id", 2);
+    const optionId = (0, import_gid.coerceGid)(optionIdRaw, "ProductOption");
+    const optionJsonRaw = args["option-json"];
+    const addValuesJsonRaw = args["add-values-json"];
+    const deleteValueIdsJsonRaw = args["delete-value-ids-json"];
+    const updateValuesJsonRaw = args["update-values-json"];
+    const hasJsonMode = Boolean(optionJsonRaw || addValuesJsonRaw || deleteValueIdsJsonRaw || updateValuesJsonRaw);
+    const addValueNames = parseRepeatableStrings(args["add-value"], "--add-value", { allowEmpty: true });
+    const deleteValueNames = parseRepeatableStrings(args["delete-value"], "--delete-value", { allowEmpty: true });
+    const renameValueSpecs = parseRepeatableStrings(args["rename-value"], "--rename-value", { allowEmpty: true });
+    const deleteValueIdSpecs = parseRepeatableStrings(args["delete-value-id"], "--delete-value-id", {
+      allowEmpty: true
+    });
+    const renameValueIdSpecs = parseRepeatableStrings(args["rename-value-id"], "--rename-value-id", {
+      allowEmpty: true
+    });
+    if (hasJsonMode) {
+      if (addValueNames.length || deleteValueNames.length || renameValueSpecs.length || deleteValueIdSpecs.length || renameValueIdSpecs.length || args.name !== void 0 || args.position !== void 0) {
+        throw new import_errors.CliError("Do not mix JSON flags with non-JSON option update flags", 2);
+      }
+    }
+    const position = parsePositiveIntFlag({ value: args.position, flag: "--position" });
+    const hasNonJsonOptionChange = typeof args.name === "string" && args.name.trim() !== "" || position !== void 0;
+    const hasNonJsonValueChange = addValueNames.length > 0 || deleteValueNames.length > 0 || renameValueSpecs.length > 0 || deleteValueIdSpecs.length > 0 || renameValueIdSpecs.length > 0;
+    if (!hasJsonMode && !hasNonJsonOptionChange && !hasNonJsonValueChange) {
+      throw new import_errors.CliError(
+        "No changes specified. Pass --name/--position and/or value change flags (e.g. --add-value, --delete-value, --rename-value).",
+        2
+      );
+    }
+    const optionUpdate = optionJsonRaw !== void 0 ? (0, import_shared.parseJsonArg)(optionJsonRaw, "--option-json") : {
+      id: optionId,
+      ...typeof args.name === "string" && args.name.trim() ? { name: args.name.trim() } : {},
+      ...position !== void 0 ? { position } : {}
+    };
+    if (!optionUpdate || typeof optionUpdate !== "object") {
+      throw new import_errors.CliError("--option-json must be a JSON object", 2);
+    }
+    if (!optionUpdate.id) optionUpdate.id = optionId;
+    const optionValuesToAdd = addValuesJsonRaw !== void 0 ? (0, import_shared.parseJsonArg)(addValuesJsonRaw, "--add-values-json") : addValueNames.map((name) => ({ name }));
+    const optionValuesToDeleteJson = deleteValueIdsJsonRaw !== void 0 ? (0, import_shared.parseJsonArg)(deleteValueIdsJsonRaw, "--delete-value-ids-json") : void 0;
+    const optionValuesToUpdate = updateValuesJsonRaw !== void 0 ? (0, import_shared.parseJsonArg)(updateValuesJsonRaw, "--update-values-json") : void 0;
+    const optionValuesToDeleteFromIds = deleteValueIdSpecs.map((id) => (0, import_gid.coerceGid)(id, "ProductOptionValue"));
+    const needsResolutionByName = deleteValueNames.length > 0 || renameValueSpecs.length > 0;
+    if (needsResolutionByName && ctx.dryRun) {
+      throw new import_errors.CliError(
+        "Name-based value changes are not supported in --dry-run mode. Use --delete-value-id/--rename-value-id or JSON flags.",
+        2
+      );
+    }
+    let resolvedDeletesFromNames = [];
+    let resolvedUpdatesFromNames = [];
+    if (needsResolutionByName) {
+      const options = await fetchProductOptionsForResolution({ ctx, productId });
+      const option = options.find((o) => typeof o?.id === "string" && o.id === optionId);
+      if (!option) throw new import_errors.CliError(`Option not found on product: ${optionId}`, 2);
+      const optionValues = option.optionValues ?? [];
+      const byName = /* @__PURE__ */ new Map();
+      for (const ov of optionValues) {
+        const n = typeof ov?.name === "string" ? ov.name : void 0;
+        if (!n) continue;
+        const list = byName.get(n) ?? [];
+        list.push(ov);
+        byName.set(n, list);
+      }
+      for (const name of deleteValueNames) {
+        const matches = byName.get(name) ?? [];
+        if (matches.length === 0) throw new import_errors.CliError(`Option value not found: "${name}"`, 2);
+        if (matches.length > 1) {
+          throw new import_errors.CliError(`Multiple option values named "${name}" exist. Use --delete-value-id instead.`, 2);
+        }
+        const id = matches[0]?.id;
+        if (typeof id !== "string" || !id) throw new import_errors.CliError(`Option value "${name}" is missing an ID`, 2);
+        resolvedDeletesFromNames.push(id);
+      }
+      for (const spec of renameValueSpecs) {
+        const { from, to } = parseFromTo(spec, "--rename-value");
+        const matches = byName.get(from) ?? [];
+        if (matches.length === 0) throw new import_errors.CliError(`Option value not found: "${from}"`, 2);
+        if (matches.length > 1) {
+          throw new import_errors.CliError(`Multiple option values named "${from}" exist. Use --rename-value-id instead.`, 2);
+        }
+        const id = matches[0]?.id;
+        if (typeof id !== "string" || !id) throw new import_errors.CliError(`Option value "${from}" is missing an ID`, 2);
+        resolvedUpdatesFromNames.push({ id, name: to });
+      }
+    }
+    const renameUpdatesFromIds = [];
+    for (const spec of renameValueIdSpecs) {
+      const { from, to } = parseFromTo(spec, "--rename-value-id");
+      renameUpdatesFromIds.push({ id: (0, import_gid.coerceGid)(from, "ProductOptionValue"), name: to });
+    }
+    const deletesFromJson = optionValuesToDeleteJson !== void 0 ? (() => {
+      if (!Array.isArray(optionValuesToDeleteJson)) {
+        throw new import_errors.CliError("--delete-value-ids-json must be a JSON array", 2);
+      }
+      return optionValuesToDeleteJson.map((id) => {
+        if (typeof id !== "string" || !id.trim()) throw new import_errors.CliError("delete-value-ids-json must contain strings", 2);
+        return id;
+      });
+    })() : [];
+    const deletes = Array.from(/* @__PURE__ */ new Set([...optionValuesToDeleteFromIds, ...resolvedDeletesFromNames, ...deletesFromJson]));
+    const updates = [
+      ...Array.isArray(optionValuesToUpdate) ? optionValuesToUpdate : optionValuesToUpdate ? [optionValuesToUpdate] : [],
+      ...resolvedUpdatesFromNames,
+      ...renameUpdatesFromIds
+    ];
+    if (optionValuesToAdd !== void 0 && optionValuesToAdd !== null && !Array.isArray(optionValuesToAdd)) {
+      throw new import_errors.CliError("--add-values-json must be a JSON array", 2);
+    }
+    if (optionValuesToUpdate !== void 0 && optionValuesToUpdate !== null && !Array.isArray(optionValuesToUpdate)) {
+      throw new import_errors.CliError("--update-values-json must be a JSON array", 2);
+    }
+    const variantStrategy = normalizeProductOptionUpdateVariantStrategy(args["variant-strategy"]);
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelectionForOptions(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productOptionUpdate: {
+        __args: {
+          productId,
+          option: optionUpdate,
+          ...Array.isArray(optionValuesToAdd) && optionValuesToAdd.length ? { optionValuesToAdd } : {},
+          ...deletes.length ? { optionValuesToDelete: deletes } : {},
+          ...updates.length ? { optionValuesToUpdate: updates } : {},
+          ...variantStrategy ? { variantStrategy } : {}
+        },
+        product: selection,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productOptionUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: result.productOptionUpdate?.product, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "options delete") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "option-id": { type: "string", multiple: true },
+        "option-name": { type: "string", multiple: true },
+        strategy: { type: "string" }
+      }
+    });
+    const productId = requireProductIdForSubverb(args);
+    const optionIdsRaw = (0, import_shared.parseStringList)(args["option-id"], "--option-id", { allowEmpty: true });
+    const optionNames = (0, import_shared.parseStringList)(args["option-name"], "--option-name", { allowEmpty: true });
+    const strategy = normalizeProductOptionDeleteStrategy(args.strategy);
+    if (optionIdsRaw.length === 0 && optionNames.length === 0) {
+      throw new import_errors.CliError("Missing options: pass one or more --option-id and/or --option-name entries", 2);
+    }
+    if (ctx.dryRun && optionNames.length > 0) {
+      throw new import_errors.CliError("Option name resolution is not supported in --dry-run mode. Use --option-id instead.", 2);
+    }
+    const optionIds = optionIdsRaw.map((id) => (0, import_gid.coerceGid)(id, "ProductOption"));
+    if (optionNames.length > 0) {
+      const options = await fetchProductOptionsForResolution({ ctx, productId });
+      for (const name of optionNames) {
+        const opt = resolveSingleOptionByName(options, name);
+        if (!opt) throw new import_errors.CliError(`Option not found on product: "${name}"`, 2);
+        const id = opt?.id;
+        if (typeof id !== "string" || !id) throw new import_errors.CliError(`Option "${name}" is missing an ID`, 2);
+        optionIds.push(id);
+      }
+    }
+    const uniqueOptionIds = Array.from(new Set(optionIds));
+    const result = await (0, import_router.runMutation)(ctx, {
+      productOptionsDelete: {
+        __args: { productId, options: uniqueOptionIds, ...strategy ? { strategy } : {} },
+        deletedOptionsIds: true,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productOptionsDelete, failOnUserErrors: ctx.failOnUserErrors });
+    const deleted = result.productOptionsDelete?.deletedOptionsIds ?? [];
+    if (ctx.quiet) {
+      for (const id of deleted) {
+        if (typeof id === "string" && id) console.log(id);
+      }
+      return;
+    }
+    (0, import_output.printNode)({
+      node: { deletedOptionsIds: deleted.filter((id) => typeof id === "string" && id.length > 0) },
+      format: ctx.format,
+      quiet: false
+    });
+    return;
+  }
+  if (verb === "options reorder") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        order: { type: "string", multiple: true },
+        "options-json": { type: "string" }
+      }
+    });
+    const productId = requireProductIdForSubverb(args);
+    const orderSpecs = parseRepeatableStrings(args.order, "--order", { allowEmpty: true });
+    const optionsJsonRaw = args["options-json"];
+    if (orderSpecs.length > 0 && optionsJsonRaw) {
+      throw new import_errors.CliError("Do not pass both --order and --options-json", 2);
+    }
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelectionForOptions(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const optionsInput = optionsJsonRaw !== void 0 ? (0, import_shared.parseJsonArg)(optionsJsonRaw, "--options-json") : void 0;
+    let options = [];
+    if (optionsInput !== void 0) {
+      if (!Array.isArray(optionsInput)) throw new import_errors.CliError("--options-json must be a JSON array", 2);
+      options = optionsInput;
+    } else {
+      if (orderSpecs.length === 0) throw new import_errors.CliError("Missing order: pass one or more --order entries, or --options-json", 2);
+      const parsed = [];
+      const hasAnyValueOrder = orderSpecs.some((s) => s.includes("="));
+      if (hasAnyValueOrder && ctx.dryRun) {
+        throw new import_errors.CliError("Value reordering via --order is not supported in --dry-run mode. Use --options-json.", 2);
+      }
+      let optionsForValidation;
+      if (hasAnyValueOrder) {
+        optionsForValidation = await fetchProductOptionsForResolution({ ctx, productId });
+      }
+      for (const spec of orderSpecs) {
+        const trimmed = spec.trim();
+        const eq = trimmed.indexOf("=");
+        const optionToken = (eq === -1 ? trimmed : trimmed.slice(0, eq)).trim();
+        if (!optionToken) throw new import_errors.CliError("--order cannot be empty", 2);
+        const optionInput = looksLikeGidOrNumericId(optionToken) ? { id: (0, import_gid.coerceGid)(optionToken, "ProductOption") } : { name: optionToken };
+        if (eq !== -1) {
+          const valuesPart = trimmed.slice(eq + 1).trim();
+          if (!valuesPart) throw new import_errors.CliError(`--order "${spec}" must include at least one value after '='`, 2);
+          const valueTokens = valuesPart.split(",").map((v) => v.trim()).filter(Boolean);
+          if (valueTokens.length === 0) throw new import_errors.CliError(`--order "${spec}" must include at least one value after '='`, 2);
+          if (!optionsForValidation) throw new import_errors.CliError("Internal error: missing options for validation", 2);
+          const resolvedOption = "id" in optionInput ? optionsForValidation.find((o) => typeof o?.id === "string" && o.id === optionInput.id) : resolveSingleOptionByName(optionsForValidation, optionInput.name);
+          if (!resolvedOption) {
+            const ref = "id" in optionInput ? optionInput.id : `"${optionInput.name}"`;
+            throw new import_errors.CliError(`Option not found on product: ${ref}`, 2);
+          }
+          const optionValues = resolvedOption.optionValues ?? [];
+          const byName = /* @__PURE__ */ new Map();
+          const existingIds = [];
+          for (const ov of optionValues) {
+            const id = typeof ov?.id === "string" ? ov.id : void 0;
+            const name = typeof ov?.name === "string" ? ov.name : void 0;
+            if (id) existingIds.push(id);
+            if (name) {
+              const list = byName.get(name) ?? [];
+              list.push(ov);
+              byName.set(name, list);
+            }
+          }
+          const providedIds = [];
+          for (const vt of valueTokens) {
+            if (looksLikeGidOrNumericId(vt)) {
+              providedIds.push((0, import_gid.coerceGid)(vt, "ProductOptionValue"));
+              continue;
+            }
+            const matches = byName.get(vt) ?? [];
+            if (matches.length === 0) throw new import_errors.CliError(`Option value not found: "${vt}"`, 2);
+            if (matches.length > 1) throw new import_errors.CliError(`Multiple option values named "${vt}" exist. Use IDs.`, 2);
+            const id = matches[0]?.id;
+            if (typeof id !== "string" || !id) throw new import_errors.CliError(`Option value "${vt}" is missing an ID`, 2);
+            providedIds.push(id);
+          }
+          const existingSet = new Set(existingIds);
+          const providedSet = new Set(providedIds);
+          if (providedSet.size !== providedIds.length) {
+            throw new import_errors.CliError("Duplicate option values provided in --order value list", 2);
+          }
+          const missing = existingIds.filter((id) => !providedSet.has(id));
+          const extra = providedIds.filter((id) => !existingSet.has(id));
+          if (missing.length || extra.length) {
+            throw new import_errors.CliError(
+              `--order "${optionToken}=..." must include the full value order for that option.`,
+              2
+            );
+          }
+          parsed.push({
+            id: resolvedOption.id,
+            values: providedIds.map((id) => ({ id }))
+          });
+        } else {
+          parsed.push(optionInput);
+        }
+      }
+      options = parsed;
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      productOptionsReorder: {
+        __args: { productId, options },
+        product: selection,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productOptionsReorder, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: result.productOptionsReorder?.product, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "combined-listing-update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "parent-product-id": { type: "string" },
+        title: { type: "string" },
+        "products-added": { type: "string" },
+        "products-edited": { type: "string" },
+        "products-removed-ids": { type: "string", multiple: true },
+        "options-and-values": { type: "string" }
+      }
+    });
+    const parentProductId = (0, import_shared.requireId)(args["parent-product-id"], "Product", "--parent-product-id");
+    const optionsAndValues = args["options-and-values"] ? (0, import_shared.parseJsonArg)(args["options-and-values"], "--options-and-values") : void 0;
+    const productsAdded = args["products-added"] ? (0, import_shared.parseJsonArg)(args["products-added"], "--products-added") : void 0;
+    const productsEdited = args["products-edited"] ? (0, import_shared.parseJsonArg)(args["products-edited"], "--products-edited") : void 0;
+    const productsRemovedIds = args["products-removed-ids"] ? (0, import_shared.parseIds)(args["products-removed-ids"], "Product") : void 0;
+    const title = args.title;
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      combinedListingUpdate: {
+        __args: {
+          parentProductId,
+          ...title ? { title } : {},
+          ...optionsAndValues !== void 0 ? { optionsAndValues } : {},
+          ...productsAdded !== void 0 ? { productsAdded } : {},
+          ...productsEdited !== void 0 ? { productsEdited } : {},
+          ...productsRemovedIds !== void 0 ? { productsRemovedIds } : {}
+        },
+        product: selection,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.combinedListingUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: result.combinedListingUpdate?.product, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "bundle-create" || verb === "bundle-update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const productSelection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const mutation = verb === "bundle-create" ? "productBundleCreate" : "productBundleUpdate";
+    const result = await (0, import_router.runMutation)(ctx, {
+      [mutation]: {
+        __args: { input: built.input },
+        productBundleOperation: {
+          id: true,
+          status: true,
+          product: productSelection
+        },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    const payload = result[mutation];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    const operation = payload?.productBundleOperation ? {
+      id: payload.productBundleOperation.id,
+      status: payload.productBundleOperation.status
+    } : void 0;
+    const product = payload?.productBundleOperation?.product;
+    if (product && typeof product === "object") {
+      (0, import_output.printNode)({
+        node: { ...product, ...operation ? { operation } : {} },
+        format: ctx.format,
+        quiet: ctx.quiet
+      });
+      return;
+    }
+    if (ctx.quiet) return;
+    (0, import_output.printJson)(
+      {
+        product: product ?? null,
+        ...operation ? { operation } : {},
+        userErrors: payload?.userErrors ?? []
+      },
+      ctx.format !== "raw"
+    );
+    return;
+  }
+  if (verb === "count") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        limit: { type: "string" },
+        "saved-search-id": { type: "string" }
+      }
+    });
+    const query = args.query;
+    const limitRaw = args.limit;
+    const savedSearchIdRaw = args["saved-search-id"];
+    const limit = limitRaw === void 0 || limitRaw === null || limitRaw === "" ? void 0 : Number(limitRaw);
+    if (limit !== void 0 && (!Number.isFinite(limit) || limit <= 0)) {
+      throw new import_errors.CliError("--limit must be a positive number", 2);
+    }
+    const savedSearchId = savedSearchIdRaw ? (0, import_gid.coerceGid)(String(savedSearchIdRaw), "SavedSearch") : void 0;
+    const result = await (0, import_router.runQuery)(ctx, {
+      productsCount: {
+        __args: {
+          ...query ? { query } : {},
+          ...savedSearchId ? { savedSearchId } : {},
+          ...limit !== void 0 ? { limit: Math.floor(limit) } : {}
+        },
+        count: true,
+        precision: true
+      }
+    });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.productsCount?.count ?? "");
+    (0, import_output.printJson)(result.productsCount, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "publish" || verb === "unpublish") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "publication-id": { type: "string", multiple: true },
+        publication: { type: "string", multiple: true },
+        at: { type: "string" },
+        now: { type: "boolean" }
+      }
+    });
+    const id = requireProductIdForRootVerb(args);
+    const publicationIds = args["publication-id"] ?? [];
+    const publicationNames = args.publication ?? [];
+    const resolvedPublicationIds = await (0, import_publishablePublish.resolvePublicationIds)({
+      ctx,
+      publicationIds,
+      publicationNames
+    });
+    if (verb === "publish") {
+      const publishDate = (0, import_publishablePublish.parsePublishDate)({ at: args.at, now: args.now });
+      const payload2 = await (0, import_publishablePublish.publishProduct)({
+        ctx,
+        id,
+        publicationIds: resolvedPublicationIds,
+        publishDate
+      });
+      if (payload2 === void 0) return;
+      if (ctx.quiet) return console.log(payload2?.publishable?.id ?? "");
+      (0, import_output.printJson)(payload2);
+      return;
+    }
+    const payload = await (0, import_publishablePublish.unpublishProduct)({
+      ctx,
+      id,
+      publicationIds: resolvedPublicationIds
+    });
+    if (payload === void 0) return;
+    if (ctx.quiet) return console.log(payload?.publishable?.id ?? "");
+    (0, import_output.printJson)(payload);
+    return;
+  }
+  if (verb === "publish-all") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        at: { type: "string" },
+        now: { type: "boolean" }
+      }
+    });
+    if (ctx.dryRun) {
+      await (0, import_resolvePublicationId.listPublications)(ctx);
+      return;
+    }
+    const id = requireProductIdForRootVerb(args);
+    const publishDate = (0, import_publishablePublish.parsePublishDate)({ at: args.at, now: args.now });
+    const publications = await (0, import_resolvePublicationId.listPublications)(ctx);
+    const publicationIds = publications.map((p) => p.id).filter(Boolean);
+    if (publicationIds.length === 0) throw new import_errors.CliError("No publications found to publish to", 2);
+    const payload = await (0, import_publishablePublish.publishProduct)({
+      ctx,
+      id,
+      publicationIds,
+      publishDate
+    });
+    if (payload === void 0) return;
+    if (ctx.quiet) return console.log(payload?.publishable?.id ?? "");
+    (0, import_output.printJson)(payload);
+    return;
+  }
+  if (verb === "metafields upsert") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const productId = requireProductIdForSubverb(args);
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const result = await (0, import_metafieldsUpsert.metafieldsUpsert)({ ctx, id: productId, input: built.input });
+    if (result === void 0) return;
+    (0, import_output.printJson)(result);
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const id = requireProductIdForRootVerb(args);
+    const selectValues = Array.isArray(args.select) ? args.select : args.select ? [args.select] : [];
+    const selectionOverride = typeof args.selection === "string" && args.selection.length > 0;
+    const select = !selectionOverride && ctx.view !== "raw" && ctx.view !== "ids" ? Array.from(/* @__PURE__ */ new Set([...selectValues, "resourcePublicationsV2.nodes.publication.name"])) : args.select;
+    const includeValues = Array.isArray(args.include) ? args.include : args.include ? [args.include] : [];
+    const include = ctx.view === "all" ? Array.from(/* @__PURE__ */ new Set([...includeValues, "resourcePublicationsV2"])) : args.include;
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelectionForGet(ctx.view),
+      select,
+      selection: args.selection,
+      include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runQuery)(ctx, { product: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    const wantsResourcePublicationsV2 = Array.isArray(args.select) && args.select.some((p) => typeof p === "string" && p.startsWith("resourcePublicationsV2"));
+    const wantsResourcePublicationsV2ViaSelection = typeof args.selection === "string" && args.selection.includes("resourcePublicationsV2");
+    const stripResourcePublicationsV2 = !(wantsResourcePublicationsV2 || wantsResourcePublicationsV2ViaSelection);
+    const withComputed = (0, import_computedFields.applyComputedFieldsToNode)(result.product, {
+      view: ctx.view,
+      stripResourcePublicationsV2
+    });
+    (0, import_output.printNode)({ node: withComputed, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        published: { type: "boolean" }
+      }
+    });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const userQuery = typeof args.query === "string" && args.query.trim() ? args.query.trim() : void 0;
+    const published = args.published === true;
+    const publishedFilter = "published_status:published";
+    const query = published && typeof userQuery === "string" && userQuery.includes(publishedFilter) ? userQuery : published ? userQuery ? `${userQuery} ${publishedFilter}` : publishedFilter : userQuery;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      products: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.products,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)(
+        "products",
+        { first, query: userQuery, sort: sortKey, reverse },
+        published ? [{ flag: "--published", value: true }] : void 0
+      )
+    });
+    return;
+  }
+  if (verb === "create") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productCreate: {
+        __args: { input: built.input },
+        product: selection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productCreate, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: result.productCreate?.product, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "archive" || verb === "unarchive") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const id = requireProductIdForRootVerb(args);
+    const status = verb === "archive" ? "ARCHIVED" : args.status ?? "DRAFT";
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productUpdate: {
+        __args: { input: { id, status } },
+        product: selection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: result.productUpdate?.product, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const id = requireProductIdForRootVerb(args);
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const input = { ...built.input, id };
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productUpdate: {
+        __args: { input },
+        product: selection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: result.productUpdate?.product, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const id = requireProductIdForRootVerb(args);
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      productDelete: {
+        __args: { input: { id } },
+        deletedProductId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productDelete?.deletedProductId ?? "");
+    (0, import_output.printJson)(result.productDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "duplicate") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const id = requireProductIdForRootVerb(args);
+    const built = (0, import_input.buildInput)({
+      inputArg: void 0,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    let newTitle = args["new-title"] ?? (built.used ? built.input?.newTitle : void 0);
+    if (!newTitle) {
+      const original = await (0, import_router.runQuery)(ctx, { product: { __args: { id }, title: true } });
+      if (original === void 0) return;
+      const title = original.product?.title;
+      if (!title) throw new import_errors.CliError("Could not resolve original product title to auto-generate newTitle", 2);
+      newTitle = `${title} (Copy)`;
+    }
+    const mutationArgs = {
+      productId: id,
+      newTitle,
+      ...built.used ? built.input : {}
+    };
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productDuplicate: {
+        __args: mutationArgs,
+        newProduct: selection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productDuplicate, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: result.productDuplicate?.newProduct, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "set-status") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const id = requireProductIdForRootVerb(args);
+    const status = args.status;
+    if (!status) throw new import_errors.CliError("Missing --status (ACTIVE|DRAFT|ARCHIVED)", 2);
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productUpdate: {
+        __args: { input: { id, status } },
+        product: selection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: result.productUpdate?.product, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "set-price") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "variant-id": { type: "string" },
+        price: { type: "string" },
+        "compare-at-price": { type: "string" },
+        "product-id": { type: "string" }
+      }
+    });
+    const variantId = (0, import_shared.requireId)(args["variant-id"], "ProductVariant", "--variant-id");
+    const price = args.price;
+    if (!price) throw new import_errors.CliError("Missing --price", 2);
+    const compareAtPrice = args["compare-at-price"];
+    const explicitProductId = args["product-id"];
+    let productId;
+    if (explicitProductId) {
+      productId = (0, import_gid.coerceGid)(explicitProductId, "Product");
+    } else {
+      if (ctx.dryRun) {
+        throw new import_errors.CliError(
+          "In --dry-run mode, --product-id is required because resolving a productId from a variantId requires executing a query.",
+          2
+        );
+      }
+      const resolved = await (0, import_router.runQuery)(ctx, {
+        productVariant: { __args: { id: variantId }, product: { id: true } }
+      });
+      if (resolved === void 0) return;
+      const pid = resolved.productVariant?.product?.id;
+      if (!pid) throw new import_errors.CliError("Could not resolve productId from --variant-id", 2);
+      productId = pid;
+    }
+    const variantSelection = (0, import_select.resolveSelection)({
+      typeName: "ProductVariant",
+      view: ctx.view,
+      baseSelection: getProductVariantSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productVariantsBulkUpdate: {
+        __args: {
+          productId,
+          variants: [
+            {
+              id: variantId,
+              price,
+              ...compareAtPrice ? { compareAtPrice } : {}
+            }
+          ]
+        },
+        userErrors: { field: true, message: true },
+        productVariants: variantSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.productVariantsBulkUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    const variant = result.productVariantsBulkUpdate?.productVariants?.[0];
+    (0, import_output.printNode)({ node: variant, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "add-tags" || verb === "remove-tags") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const id = requireProductIdForRootVerb(args);
+    const tags = parseTags(args.tags);
+    const mutationField = verb === "add-tags" ? "tagsAdd" : "tagsRemove";
+    const nodeSelection = (0, import_select.resolveSelection)({
+      typeName: "Product",
+      view: ctx.view,
+      baseSelection: getProductSelectionForTags(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const request = {
+      [mutationField]: {
+        __args: { id, tags },
+        node: { __typename: true, on_Product: nodeSelection },
+        userErrors: { field: true, message: true }
+      }
+    };
+    const result = await (0, import_router.runMutation)(ctx, request);
+    if (result === void 0) return;
+    const payload = result[mutationField];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printNode)({ node: payload?.node, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "media add") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        url: { type: "string", multiple: true },
+        alt: { type: "string" },
+        "media-type": { type: "string" },
+        "media-content-type": { type: "string" },
+        wait: { type: "boolean" },
+        "poll-interval-ms": { type: "string" },
+        "timeout-ms": { type: "string" }
+      }
+    });
+    const productId = requireProductIdForSubverb(args);
+    const urls = args.url ?? [];
+    if (urls.length === 0) throw new import_errors.CliError("Missing --url (repeatable)", 2);
+    const mediaContentTypeRaw = args["media-content-type"];
+    const mediaTypeRaw = args["media-type"];
+    if (mediaContentTypeRaw && mediaTypeRaw) {
+      const a = mediaContentTypeRaw.trim().toUpperCase();
+      const b = mediaTypeRaw.trim().toUpperCase();
+      if (a && b && a !== b) {
+        throw new import_errors.CliError("Do not pass both --media-content-type and --media-type with different values", 2);
+      }
+    }
+    const mediaContentType = normalizeMediaContentType(mediaContentTypeRaw ?? mediaTypeRaw);
+    const alt = args.alt;
+    const wait = args.wait === true;
+    const pollIntervalMs = parsePositiveIntFlag({ value: args["poll-interval-ms"], flag: "--poll-interval-ms" }) ?? 1e3;
+    const timeoutMs = parsePositiveIntFlag({ value: args["timeout-ms"], flag: "--timeout-ms" }) ?? 10 * 60 * 1e3;
+    const shouldWait = wait && !ctx.dryRun;
+    const beforeIds = shouldWait ? await getTopProductMediaIds({ ctx, productId }) : [];
+    const media = urls.map((url) => ({
+      originalSource: url,
+      mediaContentType,
+      ...alt ? { alt } : {}
+    }));
+    const viewForSelection = ctx.view === "all" ? "full" : ctx.view;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      typeName: "Media",
+      view: viewForSelection,
+      baseSelection: getProductMediaSelection(viewForSelection),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: 10
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productUpdate: {
+        __args: { product: { id: productId }, media },
+        product: {
+          id: true,
+          media: {
+            __args: { last: media.length, sortKey: "POSITION" },
+            nodes: nodeSelection
+          }
+        },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (!shouldWait) {
+      const connection = result.productUpdate?.product?.media ?? { nodes: [], pageInfo: void 0 };
+      (0, import_output.printConnection)({ connection, format: ctx.format, quiet: ctx.quiet });
+      return;
+    }
+    const afterIds = await getTopProductMediaIds({ ctx, productId });
+    const before = new Set(beforeIds);
+    const createdIds = afterIds.filter((mid) => !before.has(mid)).slice(0, urls.length);
+    if (createdIds.length !== urls.length) {
+      throw new import_errors.CliError(
+        `Unable to determine created media IDs for waiting (expected ${urls.length}, got ${createdIds.length}).`,
+        2
+      );
+    }
+    const final = await (0, import_waitForReady.waitForFilesReadyOrFailed)({ ctx, ids: createdIds, pollIntervalMs, timeoutMs });
+    if (ctx.quiet) {
+      for (const mid of createdIds) console.log(mid);
+    } else {
+      (0, import_output.printConnection)({
+        connection: { nodes: final.nodes, pageInfo: void 0 },
+        format: ctx.format,
+        quiet: false
+      });
+    }
+    if (final.failedIds.length > 0) {
+      throw new import_errors.CliError(`One or more media files failed processing: ${final.failedIds.join(", ")}`, 2);
+    }
+    return;
+  }
+  if (verb === "media upload") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        file: { type: "string", multiple: true },
+        filename: { type: "string" },
+        alt: { type: "string" },
+        "content-type": { type: "string" },
+        "mime-type": { type: "string" },
+        "media-type": { type: "string" },
+        "media-content-type": { type: "string" },
+        wait: { type: "boolean" },
+        "poll-interval-ms": { type: "string" },
+        "timeout-ms": { type: "string" }
+      }
+    });
+    const id = requireProductIdForSubverb(args);
+    const filePaths = args.file ?? [];
+    if (filePaths.length === 0) throw new import_errors.CliError("Missing --file (repeatable)", 2);
+    const usesStdin = filePaths.includes("-");
+    if (usesStdin && filePaths.length !== 1) {
+      throw new import_errors.CliError("When using --file -, provide exactly one --file", 2);
+    }
+    let cleanupStdin;
+    try {
+      let effectiveFilePaths = filePaths;
+      if (usesStdin) {
+        const stdinFile = await (0, import_stdinFile.writeStdinToTempFile)({ filename: args.filename ?? "" });
+        cleanupStdin = stdinFile.cleanup;
+        effectiveFilePaths = [stdinFile.filePath];
+      }
+      const mediaContentTypeRaw = args["media-content-type"];
+      const mediaTypeRaw = args["media-type"];
+      if (mediaContentTypeRaw && mediaTypeRaw) {
+        const a = mediaContentTypeRaw.trim().toUpperCase();
+        const b = mediaTypeRaw.trim().toUpperCase();
+        if (a && b && a !== b) {
+          throw new import_errors.CliError("Do not pass both --media-content-type and --media-type with different values", 2);
+        }
+      }
+      const forcedMediaType = mediaContentTypeRaw ?? mediaTypeRaw;
+      const forced = forcedMediaType ? normalizeMediaContentType(forcedMediaType) : void 0;
+      const resourceOverride = forced ? mediaTypeToStagedResource(forced) : void 0;
+      const mimeTypeRaw = args["mime-type"];
+      const contentTypeRaw = args["content-type"];
+      if (mimeTypeRaw && contentTypeRaw) {
+        const a = mimeTypeRaw.trim();
+        const b = contentTypeRaw.trim();
+        if (a && b && a !== b) {
+          throw new import_errors.CliError("Do not pass both --mime-type and --content-type with different values", 2);
+        }
+      }
+      const mimeType = mimeTypeRaw ?? contentTypeRaw;
+      const wait = args.wait === true;
+      const pollIntervalMs = parsePositiveIntFlag({ value: args["poll-interval-ms"], flag: "--poll-interval-ms" }) ?? 1e3;
+      const timeoutMs = parsePositiveIntFlag({ value: args["timeout-ms"], flag: "--timeout-ms" }) ?? 10 * 60 * 1e3;
+      const shouldWait = wait && !ctx.dryRun;
+      const beforeIds = shouldWait ? await getTopProductMediaIds({ ctx, productId: id }) : [];
+      const localFiles = await (0, import_stagedUploads.buildLocalFilesForStagedUpload)({
+        filePaths: effectiveFilePaths,
+        mimeType,
+        resource: resourceOverride
+      });
+      const targets = await (0, import_stagedUploads.stagedUploadLocalFiles)(ctx, localFiles);
+      if (targets === void 0) return;
+      const alt = args.alt;
+      const media = targets.map((t, i) => {
+        const local = localFiles[i];
+        if (!t.resourceUrl) throw new import_errors.CliError(`Missing staged target resourceUrl for ${local.filename}`, 2);
+        return {
+          originalSource: t.resourceUrl,
+          mediaContentType: forced ?? stagedResourceToMediaType(local.resource),
+          ...alt ? { alt } : {}
+        };
+      });
+      const viewForSelection = ctx.view === "all" ? "full" : ctx.view;
+      const nodeSelection = (0, import_select.resolveSelection)({
+        typeName: "Media",
+        view: viewForSelection,
+        baseSelection: getProductMediaSelection(viewForSelection),
+        select: args.select,
+        selection: args.selection,
+        include: args.include,
+        ensureId: ctx.quiet,
+        defaultConnectionFirst: 10
+      });
+      const result = await (0, import_router.runMutation)(ctx, {
+        productUpdate: {
+          __args: { product: { id }, media },
+          product: {
+            id: true,
+            media: {
+              __args: { last: media.length, sortKey: "POSITION" },
+              nodes: nodeSelection
+            }
+          },
+          userErrors: { field: true, message: true }
+        }
+      });
+      if (result === void 0) return;
+      (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
+      const connection = result.productUpdate?.product?.media ?? { nodes: [], pageInfo: void 0 };
+      if (!shouldWait) {
+        (0, import_output.printConnection)({ connection, format: ctx.format, quiet: ctx.quiet });
+        return;
+      }
+      const afterIds = await getTopProductMediaIds({ ctx, productId: id });
+      const before = new Set(beforeIds);
+      const expectedCount = localFiles.length;
+      const createdIds = afterIds.filter((mid) => !before.has(mid)).slice(0, expectedCount);
+      if (createdIds.length !== expectedCount) {
+        throw new import_errors.CliError(
+          `Unable to determine created media IDs for waiting (expected ${expectedCount}, got ${createdIds.length}).`,
+          2
+        );
+      }
+      const final = await (0, import_waitForReady.waitForFilesReadyOrFailed)({ ctx, ids: createdIds, pollIntervalMs, timeoutMs });
+      if (ctx.quiet) {
+        for (const mid of createdIds) console.log(mid);
+      } else {
+        (0, import_output.printConnection)({
+          connection: { nodes: final.nodes, pageInfo: void 0 },
+          format: ctx.format,
+          quiet: false
+        });
+      }
+      if (final.failedIds.length > 0) {
+        throw new import_errors.CliError(`One or more media files failed processing: ${final.failedIds.join(", ")}`, 2);
+      }
+      return;
+    } finally {
+      if (cleanupStdin) await cleanupStdin();
+    }
+  }
+  if (verb === "media list") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const id = requireProductIdForSubverb(args);
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const result = await (0, import_router.runQuery)(ctx, {
+      product: {
+        __args: { id },
+        media: {
+          __args: { first, after },
+          pageInfo: { hasNextPage: true, endCursor: true },
+          nodes: productMediaSelection
+        }
+      }
+    });
+    if (result === void 0) return;
+    const connection = result.product?.media ?? { nodes: [], pageInfo: void 0 };
+    (0, import_output.printConnection)({
+      connection,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: {
+        base: "shop products media list",
+        first,
+        extraFlags: [{ flag: "--product-id", value: id }]
+      }
+    });
+    return;
+  }
+  if (verb === "media remove") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "media-id": { type: "string", multiple: true }
+      }
+    });
+    const productId = requireProductIdForSubverb(args);
+    const mediaIds = args["media-id"] ?? [];
+    if (mediaIds.length === 0) throw new import_errors.CliError("Missing --media-id (repeatable)", 2);
+    const files = mediaIds.map((id) => ({
+      id: normalizeMediaId(id),
+      referencesToRemove: [productId]
+    }));
+    const result = await (0, import_router.runMutation)(ctx, {
+      fileUpdate: {
+        __args: { files },
+        files: { id: true, alt: true, fileStatus: true, updatedAt: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fileUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    const removedMediaIds = (result.fileUpdate?.files ?? []).map((f) => typeof f?.id === "string" ? f.id : void 0).filter((id) => typeof id === "string" && id.trim() !== "");
+    if (ctx.quiet) return (0, import_output.printIds)(removedMediaIds);
+    (0, import_output.printJson)(
+      {
+        productId,
+        removedMediaIds
+      },
+      ctx.format !== "raw"
+    );
+    return;
+  }
+  if (verb === "media update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "media-id": { type: "string" },
+        alt: { type: "string" }
+      }
+    });
+    const mediaIdRaw = args["media-id"];
+    if (!mediaIdRaw) throw new import_errors.CliError("Missing --media-id", 2);
+    const alt = args.alt;
+    if (alt === void 0) throw new import_errors.CliError("Missing --alt", 2);
+    const files = [{ id: normalizeMediaId(mediaIdRaw), alt }];
+    const result = await (0, import_router.runMutation)(ctx, {
+      fileUpdate: {
+        __args: { files },
+        files: { id: true, alt: true, fileStatus: true, updatedAt: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fileUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(files[0].id);
+    (0, import_output.printJson)(result.fileUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "media reorder") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        moves: { type: "string" },
+        move: { type: "string", multiple: true }
+      }
+    });
+    const id = requireProductIdForSubverb(args);
+    let moves = [];
+    if (args.moves) {
+      try {
+        const parsed = JSON.parse(args.moves);
+        if (!Array.isArray(parsed)) throw new import_errors.CliError("--moves must be a JSON array", 2);
+        moves = parsed;
+      } catch (err) {
+        throw new import_errors.CliError(`--moves must be valid JSON: ${err.message}`, 2);
+      }
+    } else if (args.move) {
+      const raw = args.move;
+      const parsedMoves = [];
+      for (const item of raw) {
+        const parts = item.split(":");
+        if (parts.length !== 2) throw new import_errors.CliError("--move must be <mediaId>:<newPosition>", 2);
+        const mediaId = parts[0].trim();
+        const pos = Number(parts[1].trim());
+        if (!mediaId) throw new import_errors.CliError("--move mediaId cannot be empty", 2);
+        if (!Number.isFinite(pos) || pos < 0) throw new import_errors.CliError("--move newPosition must be a non-negative number", 2);
+        parsedMoves.push({ id: normalizeMediaId(mediaId), newPosition: Math.floor(pos) });
+      }
+      moves = parsedMoves;
+    }
+    if (moves.length === 0) {
+      throw new import_errors.CliError("Missing moves: pass either --moves <json> or --move <mediaId>:<newPosition> (repeatable)", 2);
+    }
+    const normalizedMoves = moves.map((move, i) => {
+      const id2 = move?.id;
+      const newPosition = move?.newPosition;
+      if (typeof id2 !== "string" || !id2.trim()) {
+        throw new import_errors.CliError(`moves[${i}].id is required`, 2);
+      }
+      const pos = Number(newPosition);
+      if (!Number.isFinite(pos) || pos < 0) {
+        throw new import_errors.CliError(`moves[${i}].newPosition must be a non-negative number`, 2);
+      }
+      return { id: normalizeMediaId(id2), newPosition: Math.floor(pos) };
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productReorderMedia: {
+        __args: { id, moves: normalizedMoves },
+        job: { id: true, done: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productReorderMedia, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productReorderMedia?.job?.id ?? "");
+    (0, import_output.printJson)(result.productReorderMedia, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for products: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runProducts
+});
+//# sourceMappingURL=products.js.map