shop-cli 0.1.0 → 0.1.2

package/dist/cli/verbs/products.js

@@ -23,6 +23,7 @@ __export(products_exports, {
 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");
@@ -30,18 +31,48 @@ 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 productMediaSelection = {
+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 } },
+  preview: { status: true, image: { url: true } }
+};
+const productMediaSelection = {
   mediaErrors: { code: true, message: true },
-  mediaWarnings: { code: true, message: true }
+  mediaWarnings: { code: true, message: true },
+  ...productMediaSummarySelection
 };
 const productSummarySelection = {
   id: true,
@@ -63,18 +94,96 @@ 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);
@@ -85,7 +194,39 @@ 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-type must be IMAGE|VIDEO|MODEL_3D|EXTERNAL_VIDEO", 2);
+  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();
@@ -108,11 +249,143 @@ const stagedResourceToMediaType = (resource) => {
   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(
       [
@@ -125,14 +398,14 @@ const runProducts = async ({
         "  tags|types|vendors",
         "  change-status|set",
         "  join-selling-plan-groups|leave-selling-plan-groups",
-        "  option-update|options-create|options-delete|options-reorder",
+        "  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",
-        "  create-media|update-media|delete-media|reorder-media",
         "",
         "Common output flags:",
         "  --view summary|ids|full|raw",
@@ -142,7 +415,266 @@ const runProducts = async ({
     );
     return;
   }
-  if (verb === "reorder-media") verb = "media reorder";
+  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;
@@ -313,21 +845,29 @@ const runProducts = async ({
     return;
   }
   if (verb === "change-status") {
-    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
-    const productId = (0, import_shared.requireId)(args.id, "Product");
+    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: productSummarySelection,
+        product: selection,
         userErrors: { field: true, message: true }
       }
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productChangeStatus, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productChangeStatus?.product?.id ?? "");
-    (0, import_output.printJson)(result.productChangeStatus, ctx.format !== "raw");
+    (0, import_output.printNode)({ node: result.productChangeStatus?.product, format: ctx.format, quiet: ctx.quiet });
     return;
   }
   if (verb === "set") {
@@ -381,192 +921,439 @@ const runProducts = async ({
     return;
   }
   if (verb === "join-selling-plan-groups" || verb === "leave-selling-plan-groups") {
-    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "group-ids": { type: "string", multiple: true } } });
-    const id = (0, import_shared.requireId)(args.id, "Product");
+    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: { id: true, title: true },
+        product: selection,
         userErrors: { field: true, message: true }
       }
     });
     if (result === void 0) return;
     const payload = result[mutation];
     (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(payload?.product?.id ?? "");
-    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    (0, import_output.printNode)({ node: payload?.product, format: ctx.format, quiet: ctx.quiet });
     return;
   }
-  if (verb === "create-media" || verb === "update-media") {
-    const args = (0, import_router.parseStandardArgs)({
-      argv,
-      extraOptions: {
-        "product-id": { type: "string" },
-        media: { type: "string" }
-      }
+  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 productId = (0, import_shared.requireId)(args["product-id"], "Product");
-    const media = (0, import_shared.parseJsonArg)(args.media, "--media");
-    if (!Array.isArray(media)) throw new import_errors.CliError("--media must be a JSON array", 2);
-    const mutation = verb === "create-media" ? "productCreateMedia" : "productUpdateMedia";
-    const result = await (0, import_router.runMutation)(ctx, {
-      [mutation]: {
-        __args: { productId, media },
-        media: productMediaSelection,
-        mediaUserErrors: { code: true, field: true, message: true },
-        product: { id: true, title: true }
+    const result = await (0, import_router.runQuery)(ctx, {
+      product: {
+        __args: { id: productId },
+        options: selection
       }
     });
     if (result === void 0) return;
-    const payload = result[mutation];
-    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(payload?.product?.id ?? "");
-    (0, import_output.printJson)(payload, ctx.format !== "raw");
-    return;
-  }
-  if (verb === "delete-media") {
-    const args = (0, import_router.parseStandardArgs)({
-      argv,
-      extraOptions: {
-        "product-id": { type: "string" },
-        "media-ids": { type: "string", multiple: true }
-      }
-    });
-    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
-    const mediaIds = (0, import_shared.parseStringList)(args["media-ids"], "--media-ids");
-    const result = await (0, import_router.runMutation)(ctx, {
-      productDeleteMedia: {
-        __args: { productId, mediaIds },
-        deletedMediaIds: true,
-        deletedProductImageIds: true,
-        mediaUserErrors: { code: true, field: true, message: true },
-        product: { id: true, title: true }
-      }
+    const options = result.product?.options ?? [];
+    (0, import_output.printConnection)({
+      connection: { nodes: options, pageInfo: void 0 },
+      format: ctx.format,
+      quiet: ctx.quiet
     });
-    if (result === void 0) return;
-    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productDeleteMedia, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productDeleteMedia?.product?.id ?? "");
-    (0, import_output.printJson)(result.productDeleteMedia, ctx.format !== "raw");
     return;
   }
-  if (verb === "option-update") {
+  if (verb === "options create") {
     const args = (0, import_router.parseStandardArgs)({
       argv,
       extraOptions: {
         "product-id": { type: "string" },
-        option: { type: "string" },
-        "option-values-to-add": { type: "string" },
-        "option-values-to-delete": { type: "string" },
-        "option-values-to-update": { type: "string" },
+        option: { type: "string", multiple: true },
+        "options-json": { type: "string" },
         "variant-strategy": { type: "string" }
       }
     });
-    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
-    const option = (0, import_shared.parseJsonArg)(args.option, "--option");
-    const optionValuesToAdd = args["option-values-to-add"] ? (0, import_shared.parseJsonArg)(args["option-values-to-add"], "--option-values-to-add") : void 0;
-    const optionValuesToDelete = args["option-values-to-delete"] ? (0, import_shared.parseJsonArg)(args["option-values-to-delete"], "--option-values-to-delete") : void 0;
-    const optionValuesToUpdate = args["option-values-to-update"] ? (0, import_shared.parseJsonArg)(args["option-values-to-update"], "--option-values-to-update") : void 0;
-    const variantStrategy = args["variant-strategy"];
+    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, {
-      productOptionUpdate: {
-        __args: {
-          productId,
-          option,
-          ...optionValuesToAdd !== void 0 ? { optionValuesToAdd } : {},
-          ...optionValuesToDelete !== void 0 ? { optionValuesToDelete } : {},
-          ...optionValuesToUpdate !== void 0 ? { optionValuesToUpdate } : {},
-          ...variantStrategy ? { variantStrategy } : {}
-        },
-        product: productSummarySelection,
+      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.productOptionUpdate, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productOptionUpdate?.product?.id ?? "");
-    (0, import_output.printJson)(result.productOptionUpdate, ctx.format !== "raw");
+    (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-create") {
+  if (verb === "options update") {
     const args = (0, import_router.parseStandardArgs)({
       argv,
       extraOptions: {
         "product-id": { type: "string" },
-        options: { 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 = (0, import_shared.requireId)(args["product-id"], "Product");
-    const options = (0, import_shared.parseJsonArg)(args.options, "--options");
-    if (!Array.isArray(options)) throw new import_errors.CliError("--options must be a JSON array", 2);
-    const variantStrategy = args["variant-strategy"];
+    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, {
-      productOptionsCreate: {
+      productOptionUpdate: {
         __args: {
           productId,
-          options,
+          option: optionUpdate,
+          ...Array.isArray(optionValuesToAdd) && optionValuesToAdd.length ? { optionValuesToAdd } : {},
+          ...deletes.length ? { optionValuesToDelete: deletes } : {},
+          ...updates.length ? { optionValuesToUpdate: updates } : {},
           ...variantStrategy ? { variantStrategy } : {}
         },
-        product: productSummarySelection,
+        product: selection,
         userErrors: { code: true, field: true, message: true }
       }
     });
     if (result === void 0) return;
-    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productOptionsCreate, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productOptionsCreate?.product?.id ?? "");
-    (0, import_output.printJson)(result.productOptionsCreate, ctx.format !== "raw");
+    (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") {
+  if (verb === "options delete") {
     const args = (0, import_router.parseStandardArgs)({
       argv,
       extraOptions: {
         "product-id": { type: "string" },
-        "option-ids": { type: "string", multiple: true },
+        "option-id": { type: "string", multiple: true },
+        "option-name": { type: "string", multiple: true },
         strategy: { type: "string" }
       }
     });
-    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
-    const options = (0, import_shared.parseStringList)(args["option-ids"], "--option-ids");
-    const strategy = args.strategy;
+    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, ...strategy ? { strategy } : {} },
+        __args: { productId, options: uniqueOptionIds, ...strategy ? { strategy } : {} },
         deletedOptionsIds: true,
-        product: productSummarySelection,
         userErrors: { code: true, field: true, message: true }
       }
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productOptionsDelete, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productOptionsDelete?.product?.id ?? "");
-    (0, import_output.printJson)(result.productOptionsDelete, ctx.format !== "raw");
+    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") {
+  if (verb === "options reorder") {
     const args = (0, import_router.parseStandardArgs)({
       argv,
       extraOptions: {
         "product-id": { type: "string" },
-        options: { type: "string" }
+        order: { type: "string", multiple: true },
+        "options-json": { type: "string" }
       }
     });
-    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
-    const options = (0, import_shared.parseJsonArg)(args.options, "--options");
-    if (!Array.isArray(options)) throw new import_errors.CliError("--options must be a JSON array", 2);
+    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: productSummarySelection,
+        product: selection,
         userErrors: { code: true, field: true, message: true }
       }
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productOptionsReorder, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productOptionsReorder?.product?.id ?? "");
-    (0, import_output.printJson)(result.productOptionsReorder, ctx.format !== "raw");
+    (0, import_output.printNode)({ node: result.productOptionsReorder?.product, format: ctx.format, quiet: ctx.quiet });
     return;
   }
   if (verb === "combined-listing-update") {
@@ -581,12 +1368,21 @@ const runProducts = async ({
         "options-and-values": { type: "string" }
       }
     });
-    const parentProductId = (0, import_shared.requireId)(args["parent-product-id"], "Product");
+    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: {
@@ -597,14 +1393,13 @@ const runProducts = async ({
           ...productsEdited !== void 0 ? { productsEdited } : {},
           ...productsRemovedIds !== void 0 ? { productsRemovedIds } : {}
         },
-        product: productSummarySelection,
+        product: selection,
         userErrors: { code: true, field: true, message: true }
       }
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.combinedListingUpdate, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.combinedListingUpdate?.product?.id ?? "");
-    (0, import_output.printJson)(result.combinedListingUpdate, ctx.format !== "raw");
+    (0, import_output.printNode)({ node: result.combinedListingUpdate?.product, format: ctx.format, quiet: ctx.quiet });
     return;
   }
   if (verb === "bundle-create" || verb === "bundle-update") {
@@ -615,6 +1410,15 @@ const runProducts = async ({
       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]: {
@@ -622,8 +1426,7 @@ const runProducts = async ({
         productBundleOperation: {
           id: true,
           status: true,
-          product: { id: true, title: true },
-          userErrors: { field: true, message: true }
+          product: productSelection
         },
         userErrors: { field: true, message: true }
       }
@@ -631,8 +1434,28 @@ const runProducts = async ({
     if (result === void 0) return;
     const payload = result[mutation];
     (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(payload?.productBundleOperation?.id ?? "");
-    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    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") {
@@ -671,12 +1494,14 @@ const runProducts = async ({
     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)({
@@ -688,7 +1513,7 @@ const runProducts = async ({
       const publishDate = (0, import_publishablePublish.parsePublishDate)({ at: args.at, now: args.now });
       const payload2 = await (0, import_publishablePublish.publishProduct)({
         ctx,
-        id: args.id,
+        id,
         publicationIds: resolvedPublicationIds,
         publishDate
       });
@@ -699,7 +1524,7 @@ const runProducts = async ({
     }
     const payload = await (0, import_publishablePublish.unpublishProduct)({
       ctx,
-      id: args.id,
+      id,
       publicationIds: resolvedPublicationIds
     });
     if (payload === void 0) return;
@@ -711,6 +1536,7 @@ const runProducts = async ({
     const args = (0, import_router.parseStandardArgs)({
       argv,
       extraOptions: {
+        "product-id": { type: "string" },
         at: { type: "string" },
         now: { type: "boolean" }
       }
@@ -719,13 +1545,14 @@ const runProducts = async ({
       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: args.id,
+      id,
       publicationIds,
       publishDate
     });
@@ -735,21 +1562,22 @@ const runProducts = async ({
     return;
   }
   if (verb === "metafields upsert") {
-    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    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: args.id, input: built.input });
+    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: {} });
-    const id = (0, import_shared.requireId)(args.id, "Product");
+    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;
@@ -829,39 +1657,57 @@ const runProducts = async ({
       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: productSummarySelection,
+        product: selection,
         userErrors: { field: true, message: true }
       }
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productCreate, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productCreate?.product?.id ?? "");
-    (0, import_output.printJson)(result.productCreate, ctx.format !== "raw");
+    (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: {} });
-    const id = (0, import_shared.requireId)(args.id, "Product");
+    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: productSummarySelection,
+        product: selection,
         userErrors: { field: true, message: true }
       }
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productUpdate?.product?.id ?? "");
-    (0, import_output.printJson)(result.productUpdate, ctx.format !== "raw");
+    (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: {} });
-    const id = (0, import_shared.requireId)(args.id, "Product");
+    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,
@@ -869,22 +1715,31 @@ const runProducts = async ({
     });
     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: productSummarySelection,
+        product: selection,
         userErrors: { field: true, message: true }
       }
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productUpdate?.product?.id ?? "");
-    (0, import_output.printJson)(result.productUpdate, ctx.format !== "raw");
+    (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: {} });
-    const id = (0, import_shared.requireId)(args.id, "Product");
+    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: {
@@ -900,8 +1755,8 @@ const runProducts = async ({
     return;
   }
   if (verb === "duplicate") {
-    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
-    const id = (0, import_shared.requireId)(args.id, "Product");
+    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,
@@ -920,35 +1775,53 @@ const runProducts = async ({
       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: productSummarySelection,
+        newProduct: selection,
         userErrors: { field: true, message: true }
       }
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productDuplicate, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productDuplicate?.newProduct?.id ?? "");
-    (0, import_output.printJson)(result.productDuplicate, ctx.format !== "raw");
+    (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: {} });
-    const id = (0, import_shared.requireId)(args.id, "Product");
+    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: productSummarySelection,
+        product: selection,
         userErrors: { field: true, message: true }
       }
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productUpdate?.product?.id ?? "");
-    (0, import_output.printJson)(result.productUpdate, ctx.format !== "raw");
+    (0, import_output.printNode)({ node: result.productUpdate?.product, format: ctx.format, quiet: ctx.quiet });
     return;
   }
   if (verb === "set-price") {
@@ -961,7 +1834,7 @@ const runProducts = async ({
         "product-id": { type: "string" }
       }
     });
-    const variantId = (0, import_shared.requireId)(args["variant-id"], "ProductVariant");
+    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"];
@@ -984,6 +1857,16 @@ const runProducts = async ({
       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: {
@@ -996,7 +1879,8 @@ const runProducts = async ({
             }
           ]
         },
-        userErrors: { field: true, message: true }
+        userErrors: { field: true, message: true },
+        productVariants: variantSelection
       }
     });
     if (result === void 0) return;
@@ -1004,19 +1888,29 @@ const runProducts = async ({
       payload: result.productVariantsBulkUpdate,
       failOnUserErrors: ctx.failOnUserErrors
     });
-    if (ctx.quiet) return console.log(variantId);
-    (0, import_output.printJson)(result.productVariantsBulkUpdate, ctx.format !== "raw");
+    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: {} });
-    const id = (0, import_shared.requireId)(args.id, "Product");
+    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: { id: true },
+        node: { __typename: true, on_Product: nodeSelection },
         userErrors: { field: true, message: true }
       }
     };
@@ -1024,91 +1918,240 @@ const runProducts = async ({
     if (result === void 0) return;
     const payload = result[mutationField];
     (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(payload?.node?.id ?? "");
-    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    (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-type": { type: "string" },
+        "media-content-type": { type: "string" },
+        wait: { type: "boolean" },
+        "poll-interval-ms": { type: "string" },
+        "timeout-ms": { type: "string" }
       }
     });
-    const id = (0, import_shared.requireId)(args.id, "Product");
+    const productId = requireProductIdForSubverb(args);
     const urls = args.url ?? [];
     if (urls.length === 0) throw new import_errors.CliError("Missing --url (repeatable)", 2);
-    const mediaContentType = normalizeMediaContentType(args["media-type"]);
+    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 }, media },
-        product: productSummarySelection,
+        __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 (ctx.quiet) return console.log(result.productUpdate?.product?.id ?? "");
-    (0, import_output.printJson)(result.productUpdate);
+    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" },
-        "media-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 = (0, import_shared.requireId)(args.id, "Product");
+    const id = requireProductIdForSubverb(args);
     const filePaths = args.file ?? [];
     if (filePaths.length === 0) throw new import_errors.CliError("Missing --file (repeatable)", 2);
-    const forcedMediaType = args["media-type"];
-    const forced = forcedMediaType ? normalizeMediaContentType(forcedMediaType) : void 0;
-    const resourceOverride = forced ? mediaTypeToStagedResource(forced) : void 0;
-    const localFiles = (0, import_stagedUploads.buildLocalFilesForStagedUpload)({
-      filePaths,
-      contentType: args["content-type"],
-      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 result = await (0, import_router.runMutation)(ctx, {
-      productUpdate: {
-        __args: { product: { id }, media },
-        product: productSummarySelection,
-        userErrors: { field: true, message: true }
+    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];
       }
-    });
-    if (result === void 0) return;
-    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(result.productUpdate?.product?.id ?? "");
-    (0, import_output.printJson)(result.productUpdate);
-    return;
+      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: {} });
-    const id = (0, import_shared.requireId)(args.id, "Product");
+    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, {
@@ -1130,7 +2173,7 @@ const runProducts = async ({
       nextPageArgs: {
         base: "shop products media list",
         first,
-        extraFlags: [{ flag: "--id", value: id }]
+        extraFlags: [{ flag: "--product-id", value: id }]
       }
     });
     return;
@@ -1139,10 +2182,11 @@ const runProducts = async ({
     const args = (0, import_router.parseStandardArgs)({
       argv,
       extraOptions: {
+        "product-id": { type: "string" },
         "media-id": { type: "string", multiple: true }
       }
     });
-    const productId = (0, import_shared.requireId)(args.id, "Product");
+    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) => ({
@@ -1158,8 +2202,15 @@ const runProducts = async ({
     });
     if (result === void 0) return;
     (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fileUpdate, failOnUserErrors: ctx.failOnUserErrors });
-    if (ctx.quiet) return console.log(productId);
-    (0, import_output.printJson)(result.fileUpdate, ctx.format !== "raw");
+    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") {
@@ -1192,11 +2243,12 @@ const runProducts = async ({
     const args = (0, import_router.parseStandardArgs)({
       argv,
       extraOptions: {
+        "product-id": { type: "string" },
         moves: { type: "string" },
         move: { type: "string", multiple: true }
       }
     });
-    const id = (0, import_shared.requireId)(args.id, "Product");
+    const id = requireProductIdForSubverb(args);
     let moves = [];
     if (args.moves) {
       try {