@01.software/cli 0.12.0 → 0.14.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 
 // src/lib/client.ts
 import {
-  CollectionClient,
+  ServerCollectionClient,
   ServerCommerceClient,
   TenantIntrospectionApi
 } from "@01.software/sdk/server";
@@ -491,11 +491,7 @@ function resolveClientCredentials(apiKeyFlag) {
   if (!publishableKey || !secretKey) {
     throw credentialError({
       message: t("AuthenticationRequired"),
-      steps: [
-        t("RunLoginToAuthenticate"),
-        t("PassApiKey"),
-        t("SetEnvVars")
-      ]
+      steps: [t("RunLoginToAuthenticate"), t("PassApiKey"), t("SetEnvVars")]
     });
   }
   if (!isValidBearerToken(secretKey)) {
@@ -510,7 +506,7 @@ function resolveClientOrThrow(apiKeyFlag) {
   const { publishableKey, secretKey } = resolveClientCredentials(apiKeyFlag);
   const serverOptions = { publishableKey, secretKey };
   return {
-    collections: new CollectionClient(
+    collections: new ServerCollectionClient(
       publishableKey,
       secretKey,
       void 0,
@@ -536,13 +532,13 @@ import { readFileSync as readFileSync2 } from "fs";
 import { basename } from "path";
 
 // src/lib/collections.ts
-import { COLLECTIONS } from "@01.software/sdk";
+import { SERVER_COLLECTIONS } from "@01.software/sdk";
 function validateCollection(name) {
-  if (COLLECTIONS.includes(name)) {
+  if (SERVER_COLLECTIONS.includes(name)) {
     return name;
   }
   const normalized = name.replace(/-/g, "").toLowerCase();
-  const suggestions = COLLECTIONS.filter((collection) => {
+  const suggestions = SERVER_COLLECTIONS.filter((collection) => {
     const candidate = collection.replace(/-/g, "").toLowerCase();
     return candidate.startsWith(normalized) || normalized.startsWith(candidate) || normalized.length >= 3 && candidate.includes(normalized);
   }).slice(0, 5);
@@ -808,79 +804,677 @@ function registerCrudCommands(program2, getClient2, getFormat2) {
   });
 }
 
-// src/commands/order.ts
+// ../contracts/src/tenant/index.ts
 import { z } from "zod";
-var idSchema = z.union([z.string().min(1), z.number()]).transform(String);
-var customerSnapshotSchema = z.object({
-  email: z.string().email("Invalid email format"),
-  name: z.string().optional(),
-  phone: z.string().optional()
+var tenantFieldConfigStateSchema = z.object({
+  hiddenFields: z.array(z.string()),
+  isHidden: z.boolean()
+}).strict();
+var tenantContextQuerySchema = z.object({
+  counts: z.literal("true").optional()
+}).strict();
+var tenantContextToolInputSchema = z.object({
+  includeCounts: z.boolean().optional().default(false).describe(
+    "Include per-collection document counts and config status (bypasses cache, slower)"
+  )
+}).strict();
+var tenantContextResponseSchema = z.object({
+  tenant: z.object({
+    id: z.string(),
+    name: z.string(),
+    plan: z.string(),
+    planSource: z.string().optional(),
+    authoritative: z.boolean().optional(),
+    capabilityVersion: z.string().optional()
+  }).strict(),
+  features: z.array(z.string()),
+  collections: z.object({
+    active: z.array(z.string()),
+    inactive: z.array(z.string())
+  }).strict(),
+  fieldConfigs: z.record(z.string(), tenantFieldConfigStateSchema),
+  counts: z.record(z.string(), z.number()).optional(),
+  config: z.object({
+    webhookConfigured: z.boolean()
+  }).strict().optional()
+}).strict();
+var tenantFeatureProgressFeatureSchema = z.enum(["ecommerce"]);
+var tenantFeatureProgressInputSchema = z.object({
+  feature: tenantFeatureProgressFeatureSchema.describe(
+    "Feature to inspect for tenant implementation readiness"
+  ),
+  includeEvidence: z.boolean().optional().default(false).describe("Include sanitized counts and static surface evidence")
+}).strict();
+var tenantFeatureProgressStatusSchema = z.enum([
+  "ready",
+  "attention",
+  "blocked"
+]);
+var tenantFeatureProgressItemStateSchema = z.enum([
+  "complete",
+  "incomplete",
+  "blocked",
+  "attention",
+  "optional",
+  "unknown",
+  "manual",
+  "not-applicable"
+]);
+var tenantFeatureProgressSeveritySchema = z.enum([
+  "required",
+  "recommended",
+  "optional"
+]);
+var tenantFeatureProgressEvidenceValueSchema = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null()
+]);
+var tenantFeatureProgressItemSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  state: tenantFeatureProgressItemStateSchema,
+  severity: tenantFeatureProgressSeveritySchema,
+  summary: z.string(),
+  evidence: z.record(z.string(), tenantFeatureProgressEvidenceValueSchema).optional()
 }).strict();
-var shippingAddressSchema = z.object({
-  postalCode: z.string().optional(),
-  address: z.string().optional(),
-  detailAddress: z.string().optional(),
-  deliveryMessage: z.string().optional(),
-  recipientName: z.string().optional(),
-  phone: z.string().optional()
+var tenantFeatureProgressGroupSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  summary: z.string().optional(),
+  items: z.array(tenantFeatureProgressItemSchema)
 }).strict();
-var orderItemSchema = z.object({
-  product: idSchema,
-  variant: idSchema,
-  option: idSchema,
-  quantity: z.number().int().positive("quantity must be a positive integer"),
-  unitPrice: z.number().optional(),
-  totalPrice: z.number().optional()
+var tenantFeatureProgressResponseSchema = z.object({
+  schemaVersion: z.literal(1),
+  feature: tenantFeatureProgressFeatureSchema,
+  status: tenantFeatureProgressStatusSchema,
+  generatedAt: z.string(),
+  tenant: z.object({
+    id: z.string(),
+    name: z.string(),
+    plan: z.string()
+  }).strict(),
+  capability: z.object({
+    effectiveFeatures: z.array(z.string()),
+    planBlocked: z.array(z.string()),
+    closureAdded: z.array(z.string())
+  }).strict(),
+  summary: z.object({
+    complete: z.number().int().nonnegative(),
+    total: z.number().int().nonnegative(),
+    blocking: z.number().int().nonnegative(),
+    manual: z.number().int().nonnegative(),
+    unknown: z.number().int().nonnegative()
+  }).strict(),
+  groups: z.array(tenantFeatureProgressGroupSchema)
 }).strict();
-var orderItemsSchema = z.array(orderItemSchema).min(1, "At least one order item is required").max(100, "Maximum 100 items per order");
-var orderStatusSchema = z.enum([
+var COLLECTION_SCHEMA_CONTRACT_VERSION = 1;
+var collectionSchemaEndpointParamsSchema = z.object({
+  collectionSlug: z.string().min(1, "collectionSlug is required")
+}).strict();
+var collectionFieldOptionSchema = z.object({
+  label: z.string(),
+  value: z.string()
+}).strict();
+var collectionFieldSchema = z.lazy(
+  () => z.object({
+    name: z.string(),
+    path: z.string(),
+    type: z.string(),
+    required: z.literal(true).optional(),
+    unique: z.literal(true).optional(),
+    hasMany: z.literal(true).optional(),
+    relationTo: z.union([z.string(), z.array(z.string())]).optional(),
+    options: z.array(collectionFieldOptionSchema).optional(),
+    hidden: z.literal(true).optional(),
+    systemManaged: z.literal(true).optional(),
+    writable: z.boolean().optional(),
+    fields: z.array(collectionFieldSchema).optional()
+  }).strict()
+);
+var collectionSchemaResponseSchema = z.object({
+  contractVersion: z.literal(COLLECTION_SCHEMA_CONTRACT_VERSION),
+  mode: z.literal("effective"),
+  collection: z.object({
+    slug: z.string(),
+    timestamps: z.boolean(),
+    alwaysActive: z.boolean(),
+    feature: z.string().nullable(),
+    systemFields: z.array(z.string()),
+    visibility: z.object({
+      collectionHidden: z.boolean(),
+      hiddenFields: z.array(z.string())
+    }).strict(),
+    fields: z.array(collectionFieldSchema)
+  }).strict()
+}).strict();
+
+// ../contracts/src/ecommerce/index.ts
+import { z as z3 } from "zod";
+
+// ../contracts/src/ecommerce/product-upsert.ts
+import { z as z2 } from "zod";
+var IdSchema = z2.union([z2.string(), z2.number()]).transform(String);
+var RemovedLegacyMediaFieldSchema = z2.unknown().optional();
+var productFieldShape = {
+  id: IdSchema.optional(),
+  title: z2.string().min(1).optional(),
+  subtitle: z2.string().optional().nullable(),
+  description: z2.string().optional().nullable(),
+  status: z2.string().optional(),
+  slug: z2.string().optional(),
+  primaryMediaItemId: IdSchema.optional().nullable(),
+  thumbnail: IdSchema.optional().nullable(),
+  images: z2.array(IdSchema).optional(),
+  mediaSets: RemovedLegacyMediaFieldSchema,
+  vendor: z2.string().optional().nullable(),
+  productType: z2.string().optional().nullable(),
+  brand: IdSchema.optional().nullable(),
+  shippingPolicy: IdSchema.optional().nullable(),
+  weight: z2.number().int().min(0).optional().nullable(),
+  minOrderQuantity: z2.number().int().min(1).optional().nullable(),
+  maxOrderQuantity: z2.number().int().min(1).optional().nullable(),
+  isFeatured: z2.boolean().optional(),
+  publishedAt: z2.string().optional().nullable(),
+  categories: z2.array(IdSchema).optional(),
+  tags: z2.array(IdSchema).optional(),
+  metadata: z2.unknown().optional()
+};
+var PRODUCT_UPSERT_PRODUCT_FIELDS = Object.keys(
+  productFieldShape
+);
+var ProductFieldsSchema = z2.object(productFieldShape).passthrough();
+var OptionValueObjectSchema = z2.object({
+  id: IdSchema.optional(),
+  value: z2.string().min(1, "Option value `value` is required"),
+  slug: z2.string().optional(),
+  swatch: z2.object({
+    type: z2.enum(["color", "media"]).optional().nullable(),
+    color: z2.string().optional().nullable(),
+    mediaItemId: IdSchema.optional().nullable()
+  }).optional().nullable(),
+  thumbnail: RemovedLegacyMediaFieldSchema,
+  images: RemovedLegacyMediaFieldSchema,
+  metadata: z2.unknown().optional()
+});
+var OptionValueInputSchema = OptionValueObjectSchema.passthrough().superRefine(
+  (value, ctx) => {
+    if (Object.prototype.hasOwnProperty.call(value, "swatchColor")) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Option value field `swatchColor` was removed. Use nested `swatch.color` instead.",
+        path: ["swatchColor"]
+      });
+    }
+  }
+);
+var OptionInputSchema = z2.object({
+  id: IdSchema.optional(),
+  title: z2.string().min(1, "Option `title` is required"),
+  slug: z2.string().optional(),
+  values: z2.array(OptionValueInputSchema).min(1, "Each option must have at least one value")
+});
+var VariantOptionValueObjectSchema = z2.object({
+  valueSlug: z2.string().optional(),
+  valueId: IdSchema.optional(),
+  value: z2.string().optional()
+}).refine((data) => Boolean(data.valueSlug ?? data.valueId ?? data.value), {
+  message: "Variant option value object requires valueSlug, valueId, or value"
+});
+var VariantInputSchema = z2.object({
+  id: IdSchema.optional(),
+  optionValues: z2.union([
+    z2.record(
+      z2.string(),
+      z2.union([z2.string(), VariantOptionValueObjectSchema])
+    ),
+    z2.array(IdSchema)
+  ]).optional(),
+  sku: z2.string().optional().nullable(),
+  title: z2.string().optional().nullable(),
+  price: z2.number().min(0),
+  compareAtPrice: z2.number().min(0).optional().nullable(),
+  stock: z2.number().int().min(0).optional(),
+  isUnlimited: z2.boolean().optional(),
+  weight: z2.number().int().min(0).optional().nullable(),
+  requiresShipping: z2.boolean().optional(),
+  barcode: z2.string().optional().nullable(),
+  externalId: z2.string().optional().nullable(),
+  isActive: z2.boolean().optional(),
+  images: z2.array(IdSchema).optional(),
+  thumbnail: RemovedLegacyMediaFieldSchema,
+  featuredMediaItemId: RemovedLegacyMediaFieldSchema,
+  metadata: z2.unknown().optional()
+});
+var ProductUpsertObjectSchema = z2.object({
+  /** Required on graph edit when the server graph is non-empty (`productId` set); optional for first seed on an empty graph. */
+  graphRevision: z2.string().optional(),
+  productId: IdSchema.optional(),
+  product: ProductFieldsSchema.optional(),
+  options: z2.array(OptionInputSchema).max(10).optional().default([]),
+  variants: z2.array(VariantInputSchema).max(500).optional().default([])
+});
+var ProductUpsertSchema = ProductUpsertObjectSchema.superRefine(
+  (data, ctx) => {
+    const nestedProductId = data.product?.id;
+    if (data.productId != null && nestedProductId != null && String(data.productId) !== String(nestedProductId)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "productId must match product.id when both are set on graph upsert.",
+        path: ["productId"]
+      });
+    }
+    const productId = data.productId ?? nestedProductId;
+    const isEdit = productId != null;
+    if (!isEdit && data.productId != null) {
+      ctx.addIssue({
+        code: "custom",
+        message: "productId is not allowed when creating a product.",
+        path: ["productId"]
+      });
+    }
+    if (!isEdit && !data.product?.title) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Product `title` is required when creating a new product.",
+        path: ["product", "title"]
+      });
+    }
+    if (isEdit && data.product) {
+      for (const key of Object.keys(data.product)) {
+        if (key !== "id") {
+          ctx.addIssue({
+            code: "custom",
+            message: "Existing product graph upsert accepts only product identity. Save document fields through Payload.",
+            path: ["product", key]
+          });
+        }
+      }
+    }
+  }
+);
+
+// ../contracts/src/ecommerce/index.ts
+var transactionStatusSchema = z3.enum([
   "pending",
   "paid",
   "failed",
+  "canceled"
+]);
+var financialStatusSchema = z3.enum([
+  "pending",
+  "paid",
   "canceled",
+  "partially_refunded",
+  "refunded"
+]);
+var orderDisplayFinancialStatusSchema = z3.enum([
+  "pending",
+  "paid",
+  "partially_refunded",
+  "refunded",
+  "voided"
+]);
+var confirmationStatusSchema = z3.enum(["unconfirmed", "confirmed"]);
+var fulfillmentOrderStatusSchema = z3.enum([
+  "open",
+  "in_progress",
+  "on_hold",
+  "canceled",
+  "closed"
+]);
+var shipmentStatusSchema = z3.enum([
+  "pending",
+  "shipped",
+  "delivered",
+  "canceled",
+  "failed"
+]);
+var orderDisplayFulfillmentStatusSchema = z3.enum([
+  "unfulfilled",
+  "in_progress",
+  "on_hold",
+  "shipped",
+  "fulfilled",
+  "canceled"
+]);
+var orderReturnStatusSchema = z3.enum([
+  "no_return",
+  "return_requested",
+  "in_progress",
+  "returned"
+]);
+var orderStatusSchema = z3.enum([
+  "pending",
+  "paid",
+  "canceled",
+  "refunded",
+  "preparing",
+  "shipped",
+  "delivered",
+  "confirmed",
+  "return_requested",
+  "return_processing",
+  "returned"
+]);
+var entityIdSchema = z3.union([z3.string().min(1), z3.number()]).transform(String);
+var createOrderItemSchema = z3.object({
+  // `product` and `option` are storefront-optional: the create-order
+  // endpoint derives the product from the variant's parent and snapshots
+  // option selection from the variant.
+  product: entityIdSchema.optional(),
+  variant: entityIdSchema,
+  option: entityIdSchema.optional(),
+  quantity: z3.number().int().positive("quantity must be a positive integer"),
+  unitPrice: z3.number().optional(),
+  totalPrice: z3.number().optional()
+}).strict();
+var createOrderSchema = z3.object({
+  pgPaymentId: z3.string().min(1).optional(),
+  orderNumber: z3.string().min(1, "orderNumber is required"),
+  customer: entityIdSchema.optional(),
+  customerSnapshot: z3.object({
+    name: z3.string().optional(),
+    email: z3.string().email("Invalid email format"),
+    phone: z3.string().optional()
+  }).strict(),
+  shippingAddress: z3.object({
+    postalCode: z3.string().optional(),
+    address: z3.string().optional(),
+    detailAddress: z3.string().optional(),
+    deliveryMessage: z3.string().optional(),
+    recipientName: z3.string().optional(),
+    phone: z3.string().optional()
+  }).strict(),
+  orderItems: z3.array(createOrderItemSchema).min(1, "At least one order item is required").max(100, "Maximum 100 items per order"),
+  totalAmount: z3.number().nonnegative("totalAmount must be non-negative"),
+  shippingAmount: z3.number().min(0).optional(),
+  discountCode: z3.string().optional()
+}).strict();
+var updateTransactionSchema = z3.object({
+  pgPaymentId: z3.string().min(1, "pgPaymentId is required").describe("PG payment ID (required)"),
+  status: transactionStatusSchema.describe(
+    "New transaction status (required)"
+  ),
+  paymentMethod: z3.string().optional().describe("Payment method (optional)"),
+  receiptUrl: z3.string().optional().describe("Receipt URL (optional)"),
+  paymentKey: z3.string().min(1).optional().describe("Provider payment key for verified paid confirmation"),
+  amount: z3.number().int().positive().optional().describe("Provider-confirmed amount for verified paid confirmation")
+}).strict();
+var providerSlugSchema = z3.string().trim().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/, "pgProvider must be lowercase slug");
+var confirmPaymentSchema = z3.object({
+  orderNumber: z3.string().min(1).optional(),
+  pgPaymentId: z3.string().min(1, "pgPaymentId is required").describe("Provider payment identifier stored on the transaction"),
+  pgProvider: providerSlugSchema.describe(
+    "Payment provider slug, e.g. toss, portone, stripe"
+  ),
+  pgOrderId: z3.string().min(1).optional(),
+  amount: z3.number().int().nonnegative("amount must be non-negative").describe("Provider-confirmed amount in minor units"),
+  currency: z3.string().min(1).optional(),
+  paymentMethod: z3.string().optional(),
+  receiptUrl: z3.string().url().optional(),
+  approvedAt: z3.string().optional(),
+  providerStatus: z3.string().optional(),
+  providerEventId: z3.string().min(1).optional(),
+  confirmationSource: z3.enum([
+    "provider_webhook",
+    "provider_lookup",
+    "provider_api_confirm",
+    "manual_server"
+  ]).optional(),
+  paymentKey: z3.string().min(1).optional().describe(
+    "Optional provider payment key from the client confirm handshake; stored for BFF/provider refund workflows (also accepted as metadata.tossPaymentKey). Local cancel does not read this field."
+  ),
+  metadata: z3.record(z3.string(), z3.unknown()).optional()
+}).strict();
+var returnReasonSchema = z3.enum([
+  "change_of_mind",
+  "defective",
+  "wrong_delivery",
+  "damaged",
+  "other"
+]);
+var restockActionSchema = z3.enum(["return_to_stock", "discard"]);
+var returnWithRefundItemSchema = z3.object({
+  orderItem: z3.union([z3.string().min(1), z3.number()]).transform(String),
+  quantity: z3.number().int().positive("quantity must be a positive integer"),
+  restockAction: restockActionSchema.default("return_to_stock"),
+  restockingFee: z3.number().min(0, "restockingFee must be non-negative").optional().describe("Restocking fee charged for this line (ADR 0005 \xA7Gap 1)")
+}).strict();
+var returnWithRefundSchema = z3.object({
+  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number (required)"),
+  reason: returnReasonSchema.optional().describe("Return reason (optional)"),
+  reasonDetail: z3.string().optional().describe("Detailed reason text (optional)"),
+  returnItems: z3.array(returnWithRefundItemSchema).min(1, "At least one return item is required").max(100, "Too many return items").describe("Array of products to return (required)"),
+  refundAmount: z3.number().min(0, "refundAmount must be non-negative").describe("Refund amount (required, min 0)"),
+  returnShippingFee: z3.number().min(0, "returnShippingFee must be non-negative").optional().describe(
+    "Return shipping fee charged to the customer (ADR 0005 \xA7Gap 1)"
+  ),
+  initialShippingRefundAmount: z3.number().min(0, "initialShippingRefundAmount must be non-negative").optional().describe("Initial order shipping amount refunded to the customer"),
+  initialShippingRefundOverrideNote: z3.string().min(1).optional().describe(
+    "Operator audit note required when overriding policy suggestion"
+  ),
+  pgPaymentId: z3.string().min(1, "pgPaymentId is required").describe("PG payment ID for refund (required)"),
+  paymentKey: z3.string().min(1).optional().describe("Provider payment key for verified refund"),
+  refundReceiptUrl: z3.string().optional().describe("Refund receipt URL (optional)")
+}).strict();
+var createReturnSchema = z3.object({
+  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number (required)"),
+  reason: returnReasonSchema.optional().describe("Return reason (optional)"),
+  reasonDetail: z3.string().optional().describe("Detailed reason text (optional)"),
+  returnItems: z3.array(returnWithRefundItemSchema).min(1, "At least one return item is required").max(100, "Too many return items").describe("Array of products to return (required)"),
+  refundAmount: z3.number().min(0, "refundAmount must be non-negative").describe(
+    "Line refund amount before initial shipping refund (required, min 0)"
+  ),
+  returnShippingFee: z3.number().min(0, "returnShippingFee must be non-negative").optional().describe("Return shipping fee charged to the customer"),
+  initialShippingRefundAmount: z3.number().min(0, "initialShippingRefundAmount must be non-negative").optional().describe("Initial order shipping amount refunded to the customer"),
+  initialShippingRefundOverrideNote: z3.string().min(1).optional().describe(
+    "Operator audit note required when overriding policy suggestion"
+  )
+}).strict();
+var cancelReasonCodeSchema = z3.enum([
+  "customer",
+  "inventory",
+  "fraud",
+  "declined",
+  "staff",
+  "other"
+]);
+var idempotencyKeySchema = z3.string().trim().min(1, "idempotencyKey is required").max(255, "idempotencyKey must be 255 characters or fewer").regex(
+  /^[\x21-\x7E]+$/,
+  "idempotencyKey must contain only printable header-safe characters"
+);
+var cancelOrderSchema = z3.object({
+  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number to cancel"),
+  reasonCode: cancelReasonCodeSchema.default("other").describe("Operator-selected cancel reason code"),
+  reasonDetail: z3.string().trim().max(2e3, "reasonDetail must be 2000 characters or fewer").optional().describe("Internal cancellation detail stored on the order")
+}).strict();
+var cancelOrderResponseBaseSchema = {
+  orderId: z3.string().min(1)
+};
+var unpaidLocalCancelCommittedResponseFields = {
+  refundedAmount: z3.literal(0),
+  providerRefunded: z3.literal(false)
+};
+var paidLocalCancelCommittedResponseFields = {
+  transactionId: z3.string().min(1),
+  refundedAmount: z3.literal(0),
+  providerRefunded: z3.literal(false),
+  refundPending: z3.literal(true)
+};
+var legacyProviderRefundResponseFields = {
+  transactionId: z3.string().min(1),
+  refundedAmount: z3.number().int().positive(),
+  refundSeq: z3.number().int().positive(),
+  providerRefunded: z3.literal(true)
+};
+var alreadyCanceledResponseFields = {
+  refundedAmount: z3.number().int().nonnegative(),
+  providerRefunded: z3.literal(false)
+};
+var alreadyCanceledRefundPendingResponseFields = {
+  transactionId: z3.string().min(1),
+  refundedAmount: z3.number().int().nonnegative(),
+  providerRefunded: z3.literal(false),
+  refundPending: z3.literal(true)
+};
+var cancelOrderReconciliationStatusSchema = z3.enum([
+  "paid",
   "preparing",
   "shipped",
   "delivered",
-  "confirmed"
+  "confirmed",
+  "return_requested",
+  "return_processing",
+  "returned",
+  "refunded"
+]);
+var cancelOrderResponseSchema = z3.union([
+  z3.object({
+    ...cancelOrderResponseBaseSchema,
+    ...paidLocalCancelCommittedResponseFields,
+    status: z3.literal("canceled"),
+    cancelCommitted: z3.literal(true)
+  }).strict(),
+  z3.object({
+    ...cancelOrderResponseBaseSchema,
+    ...unpaidLocalCancelCommittedResponseFields,
+    status: z3.literal("canceled"),
+    cancelCommitted: z3.literal(true)
+  }).strict(),
+  z3.object({
+    ...cancelOrderResponseBaseSchema,
+    ...alreadyCanceledResponseFields,
+    status: z3.literal("canceled"),
+    cancelCommitted: z3.literal(false),
+    alreadyCanceled: z3.literal(true)
+  }).strict(),
+  z3.object({
+    ...cancelOrderResponseBaseSchema,
+    ...alreadyCanceledRefundPendingResponseFields,
+    status: z3.literal("canceled"),
+    cancelCommitted: z3.literal(false),
+    alreadyCanceled: z3.literal(true)
+  }).strict(),
+  z3.object({
+    ...cancelOrderResponseBaseSchema,
+    ...legacyProviderRefundResponseFields,
+    status: cancelOrderReconciliationStatusSchema,
+    cancelCommitted: z3.literal(false),
+    reconciliationRequired: z3.literal(true)
+  }).strict()
 ]);
-var fulfillmentItemsSchema = z.array(
-  z.object({
+var resolveCancelRefundOutcomeSchema = z3.enum(["succeeded", "failed"]);
+var resolveCancelRefundSchema = z3.object({
+  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number whose pending cancel refund is being resolved"),
+  idempotencyKey: idempotencyKeySchema.describe(
+    "Stable key for this PG refund result report"
+  ),
+  outcome: resolveCancelRefundOutcomeSchema.describe(
+    "PG refund result reported by the storefront or BFF"
+  ),
+  refundedAmount: z3.number().int("refundedAmount must be an integer minor-unit amount").nonnegative("refundedAmount must be nonnegative"),
+  pgProvider: z3.string().trim().min(1, "pgProvider is required").regex(
+    /^[a-z0-9][a-z0-9_-]*$/,
+    "pgProvider must be a lowercase provider slug"
+  ),
+  pgRefundId: z3.string().trim().min(1).optional()
+}).strict().superRefine((value, ctx) => {
+  if (value.outcome === "succeeded" && value.refundedAmount <= 0) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["refundedAmount"],
+      message: "refundedAmount must be positive when outcome is succeeded"
+    });
+  }
+  if (value.outcome === "succeeded" && !value.pgRefundId) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["pgRefundId"],
+      message: "pgRefundId is required when outcome is succeeded"
+    });
+  }
+  if (value.outcome === "failed" && value.refundedAmount !== 0) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["refundedAmount"],
+      message: "refundedAmount must be 0 when outcome is failed"
+    });
+  }
+});
+var resolveCancelRefundResponseSchema = z3.union([
+  z3.object({
+    orderId: z3.string().min(1),
+    transactionId: z3.string().min(1),
+    refundTransactionId: z3.string().min(1),
+    refundedAmount: z3.number().int().positive(),
+    refundStatus: z3.literal("succeeded"),
+    transactionStatus: z3.literal("refunded")
+  }).strict(),
+  z3.object({
+    orderId: z3.string().min(1),
+    transactionId: z3.string().min(1),
+    refundTransactionId: z3.string().min(1),
+    refundedAmount: z3.literal(0),
+    refundStatus: z3.literal("failed"),
+    transactionStatus: z3.literal("paid")
+  }).strict()
+]);
+
+// src/commands/order.ts
+import { z as z4 } from "zod";
+var idSchema = z4.union([z4.string().min(1), z4.number()]).transform(String);
+var customerSnapshotSchema = z4.object({
+  email: z4.string().email("Invalid email format"),
+  name: z4.string().optional(),
+  phone: z4.string().optional()
+}).strict();
+var orderStatusSchema2 = z4.enum(["confirmed"]);
+var fulfillmentStatusSchema = z4.enum(["shipped", "delivered", "failed"]);
+var updateFulfillmentSchema = z4.object({
+  fulfillmentId: idSchema,
+  status: fulfillmentStatusSchema.optional(),
+  carrier: z4.string().min(1).optional(),
+  trackingNumber: z4.string().min(1).optional()
+}).refine(
+  (value) => value.status !== void 0 || value.carrier !== void 0 || value.trackingNumber !== void 0,
+  {
+    message: "status, carrier, or trackingNumber is required"
+  }
+);
+var fulfillmentItemsSchema = z4.array(
+  z4.object({
     orderItem: idSchema,
-    quantity: z.number().int().positive("quantity must be a positive integer")
+    quantity: z4.number().int().positive("quantity must be a positive integer")
   }).strict()
 ).min(1, "At least one fulfillment item is required").max(100, "Maximum 100 items per fulfillment");
 function registerOrderCommands(program2, getClient2, getFormat2) {
   const order = program2.command("order").description("Order management");
-  order.command("create").description("Create a new order").option("--payment-id <id>", "Payment ID").requiredOption("--order-number <num>", "Order number").requiredOption("--email <email>", "Customer email").option("--customer <id>", "Customer ID").option("--name <name>", "Customer name").option("--phone <phone>", "Customer phone").requiredOption("--shipping-address <json>", "Shipping address (JSON)").requiredOption("--products <json>", "Order products array (JSON)").requiredOption("--total-amount <n>", "Total amount", parseFloat).option("--dry-run", "Validate inputs without executing").action(async (opts) => {
+  order.command("create").description("Create a new order").option("--payment-id <id>", "Payment ID").requiredOption("--order-number <num>", "Order number").requiredOption("--email <email>", "Customer email").option("--customer <id>", "Customer ID").option("--name <name>", "Customer name").option("--phone <phone>", "Customer phone").requiredOption("--shipping-address <json>", "Shipping address (JSON)").requiredOption("--products <json>", "Order products array (JSON)").requiredOption("--total-amount <n>", "Total amount", parseFloat).option("--shipping-amount <n>", "Shipping amount", parseFloat).option("--discount-code <code>", "Discount code").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
     try {
-      const shippingAddress = parseWithSchema(
-        parseJson(opts.shippingAddress, "shipping-address"),
-        "shipping-address",
-        shippingAddressSchema
-      );
-      const orderItems = parseWithSchema(
-        parseJsonArray(opts.products, "products"),
-        "products",
-        orderItemsSchema
-      );
-      const totalAmount = parseWithSchema(
-        opts.totalAmount,
-        "total-amount",
-        z.number().nonnegative("totalAmount must be non-negative")
-      );
-      const data = {
-        pgPaymentId: opts.paymentId,
-        orderNumber: opts.orderNumber,
-        customerSnapshot: {
-          email: opts.email,
-          name: opts.name,
-          phone: opts.phone
+      const data = parseWithSchema(
+        {
+          pgPaymentId: opts.paymentId,
+          orderNumber: opts.orderNumber,
+          customerSnapshot: {
+            email: opts.email,
+            name: opts.name,
+            phone: opts.phone
+          },
+          customer: opts.customer,
+          shippingAddress: parseJson(
+            opts.shippingAddress,
+            "shipping-address"
+          ),
+          orderItems: parseJsonArray(opts.products, "products"),
+          totalAmount: opts.totalAmount,
+          shippingAmount: opts.shippingAmount,
+          discountCode: opts.discountCode
         },
-        customer: opts.customer,
-        shippingAddress,
-        orderItems,
-        totalAmount
-      };
+        "order",
+        createOrderSchema
+      );
       if (opts.dryRun) {
         printResult(
           { dryRun: true, valid: true, action: "order create", data },
@@ -889,10 +1483,7 @@ function registerOrderCommands(program2, getClient2, getFormat2) {
         return;
       }
       const client = getClient2();
-      const result = await client.commerce.orders.create({
-        ...data,
-        orderItems
-      });
+      const result = await client.commerce.orders.create(data);
       printResult(result, getFormat2());
     } catch (e) {
       exitWithError(e);
@@ -901,16 +1492,22 @@ function registerOrderCommands(program2, getClient2, getFormat2) {
   order.command("get <orderNumber>").description("Get an order by order number").action(async (orderNumber) => {
     try {
       const client = getClient2();
-      const { docs: [order2] } = await client.collections.from("orders").find({ where: { orderNumber: { equals: orderNumber } }, limit: 1, depth: 1 });
+      const {
+        docs: [order2]
+      } = await client.collections.from("orders").find({
+        where: { orderNumber: { equals: orderNumber } },
+        limit: 1,
+        depth: 1
+      });
       if (!order2) throw new Error("Order not found");
       printResult(order2, getFormat2());
     } catch (e) {
       exitWithError(e);
     }
   });
-  order.command("update <orderNumber>").description("Update order status").requiredOption("--status <status>", "New status").option("--dry-run", "Validate inputs without executing").action(async (orderNumber, opts) => {
+  order.command("update <orderNumber>").description("Confirm a delivered order purchase").requiredOption("--status <status>", "New status (confirmed only)").option("--dry-run", "Validate inputs without executing").action(async (orderNumber, opts) => {
     try {
-      const status = parseWithSchema(opts.status, "status", orderStatusSchema);
+      const status = parseWithSchema(opts.status, "status", orderStatusSchema2);
       const data = { orderNumber, status };
       if (opts.dryRun) {
         printResult(
@@ -926,6 +1523,34 @@ function registerOrderCommands(program2, getClient2, getFormat2) {
       exitWithError(e);
     }
   });
+  order.command("cancel <orderNumber>").description("Cancel an eligible order").option(
+    "--reason-code <code>",
+    "Cancel reason (customer, inventory, fraud, declined, staff, other)"
+  ).option("--reason-detail <text>", "Internal cancellation detail").option("--dry-run", "Validate inputs without executing").action(async (orderNumber, opts) => {
+    try {
+      const data = parseWithSchema(
+        {
+          orderNumber,
+          ...opts.reasonCode ? { reasonCode: opts.reasonCode } : {},
+          ...opts.reasonDetail ? { reasonDetail: opts.reasonDetail } : {}
+        },
+        "cancel",
+        cancelOrderSchema
+      );
+      if (opts.dryRun) {
+        printResult(
+          { dryRun: true, valid: true, action: "order cancel", data },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.orders.cancelOrder(data);
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
   order.command("checkout").description("Convert a cart to an order").requiredOption("--cart-id <id>", "Cart ID").option("--payment-id <id>", "Payment ID (optional for free orders)").requiredOption("--order-number <num>", "Order number").requiredOption("--customer <json>", "Customer snapshot (JSON)").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
     try {
       const customerSnapshot = parseWithSchema(
@@ -956,18 +1581,35 @@ function registerOrderCommands(program2, getClient2, getFormat2) {
       exitWithError(e);
     }
   });
-  order.command("fulfill <orderNumber>").description("Create a fulfillment for an order").requiredOption("--items <json>", "Fulfillment items array (JSON)").option("--carrier <name>", "Shipping carrier").option("--tracking-number <num>", "Tracking number").option("--dry-run", "Validate inputs without executing").action(async (orderNumber, opts) => {
+  order.command("prepare <orderNumber>").description("Move paid order fulfillment work to preparation").option("--dry-run", "Validate inputs without executing").action(async (orderNumber, opts) => {
     try {
-      const items = parseWithSchema(
+      const data = { orderNumber };
+      if (opts.dryRun) {
+        printResult(
+          { dryRun: true, valid: true, action: "order prepare", data },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.orders.prepareFulfillmentOrder(data);
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
+  order.command("fulfill <orderNumber>").description("Create a shipment for a prepared order").option("--items <json>", "Fulfillment items array (JSON)").option("--carrier <name>", "Shipping carrier").option("--tracking-number <num>", "Tracking number").option("--dry-run", "Validate inputs without executing").action(async (orderNumber, opts) => {
+    try {
+      const items = opts.items ? parseWithSchema(
         parseJsonArray(opts.items, "items"),
         "items",
         fulfillmentItemsSchema
-      );
+      ) : void 0;
       const data = {
         orderNumber,
-        items,
-        carrier: opts.carrier,
-        trackingNumber: opts.trackingNumber
+        ...opts.carrier ? { carrier: opts.carrier } : {},
+        ...opts.trackingNumber ? { trackingNumber: opts.trackingNumber } : {},
+        ...items ? { items } : {}
       };
       if (opts.dryRun) {
         printResult(
@@ -979,62 +1621,88 @@ function registerOrderCommands(program2, getClient2, getFormat2) {
       const client = getClient2();
       const result = await client.commerce.orders.createFulfillment({
         ...data,
-        items
+        ...items ? {
+          items
+        } : {}
       });
       printResult(result, getFormat2());
     } catch (e) {
       exitWithError(e);
     }
   });
+  order.command("update-fulfillment <fulfillmentId>").description("Update shipment status or tracking information").option("--status <status>", "Shipment status (shipped, delivered, failed)").option("--carrier <name>", "Shipping carrier").option("--tracking-number <num>", "Tracking number").option("--dry-run", "Validate inputs without executing").action(async (fulfillmentId, opts) => {
+    try {
+      const data = parseWithSchema(
+        {
+          fulfillmentId,
+          ...opts.status ? { status: opts.status } : {},
+          ...opts.carrier ? { carrier: opts.carrier } : {},
+          ...opts.trackingNumber ? { trackingNumber: opts.trackingNumber } : {}
+        },
+        "fulfillment",
+        updateFulfillmentSchema
+      );
+      if (opts.dryRun) {
+        printResult(
+          {
+            dryRun: true,
+            valid: true,
+            action: "order update-fulfillment",
+            data
+          },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.orders.updateFulfillment(data);
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
 }
 
 // src/commands/return.ts
-import { z as z2 } from "zod";
-var idSchema2 = z2.union([z2.string().min(1), z2.number()]).transform(String);
-var returnReasonSchema = z2.enum(["change_of_mind", "defective", "wrong_delivery", "damaged", "other"]).optional();
-var returnItemsSchema = z2.array(
-  z2.object({
-    orderItem: idSchema2,
-    quantity: z2.number().int().positive("quantity must be a positive integer"),
-    restockAction: z2.enum(["return_to_stock", "discard"]).default("return_to_stock")
-  }).strict()
-).min(1, "At least one return item is required").max(100, "Too many return items");
-var returnStatusSchema = z2.enum([
+import { z as z5 } from "zod";
+var returnStatusSchema = z5.enum([
   "processing",
   "approved",
   "rejected",
   "completed"
 ]);
-var refundAmountSchema = z2.number().nonnegative("refundAmount must be non-negative");
 function registerReturnCommands(program2, getClient2, getFormat2) {
   const ret = program2.command("return").description("Return management");
   ret.command("create <orderNumber>").description("Create a return request").requiredOption("--products <json>", "Return products array (JSON)").requiredOption("--refund-amount <n>", "Refund amount", parseFloat).option(
+    "--return-shipping-fee <n>",
+    "Return shipping fee charged to the customer",
+    parseFloat
+  ).option(
+    "--initial-shipping-refund-amount <n>",
+    "Initial order shipping refund amount",
+    parseFloat
+  ).option(
+    "--initial-shipping-refund-note <text>",
+    "Audit note for manual initial shipping refund override"
+  ).option(
     "--reason <reason>",
     "Return reason (change_of_mind, defective, wrong_delivery, damaged, other)"
   ).option("--reason-detail <text>", "Detailed reason").option("--dry-run", "Validate inputs without executing").action(async (orderNumber, opts) => {
     try {
-      const returnItems = parseWithSchema(
-        parseJsonArray(opts.products, "products"),
-        "products",
-        returnItemsSchema
-      );
-      const refundAmount = parseWithSchema(
-        opts.refundAmount,
-        "refund-amount",
-        refundAmountSchema
-      );
-      const reason = parseWithSchema(
-        opts.reason,
-        "reason",
-        returnReasonSchema
+      const data = parseWithSchema(
+        {
+          orderNumber,
+          returnItems: parseJsonArray(opts.products, "products"),
+          refundAmount: opts.refundAmount,
+          returnShippingFee: opts.returnShippingFee,
+          reason: opts.reason,
+          reasonDetail: opts.reasonDetail,
+          initialShippingRefundAmount: opts.initialShippingRefundAmount,
+          initialShippingRefundOverrideNote: opts.initialShippingRefundNote
+        },
+        "return",
+        createReturnSchema
       );
-      const data = {
-        orderNumber,
-        returnItems,
-        refundAmount,
-        reason,
-        reasonDetail: opts.reasonDetail
-      };
       if (opts.dryRun) {
         printResult(
           { dryRun: true, valid: true, action: "return create", data },
@@ -1045,7 +1713,7 @@ function registerReturnCommands(program2, getClient2, getFormat2) {
       const client = getClient2();
       const result = await client.commerce.orders.createReturn({
         ...data,
-        returnItems
+        returnItems: data.returnItems
       });
       printResult(result, getFormat2());
     } catch (e) {
@@ -1057,7 +1725,11 @@ function registerReturnCommands(program2, getClient2, getFormat2) {
     "New status (processing, approved, rejected, completed)"
   ).option("--dry-run", "Validate inputs without executing").action(async (returnId, opts) => {
     try {
-      const status = parseWithSchema(opts.status, "status", returnStatusSchema);
+      const status = parseWithSchema(
+        opts.status,
+        "status",
+        returnStatusSchema
+      );
       const data = { returnId, status };
       if (opts.dryRun) {
         printResult(
@@ -1073,32 +1745,36 @@ function registerReturnCommands(program2, getClient2, getFormat2) {
       exitWithError(e);
     }
   });
-  ret.command("refund <orderNumber>").description("Return with refund").requiredOption("--products <json>", "Return products array (JSON)").requiredOption("--refund-amount <n>", "Refund amount", parseFloat).requiredOption("--payment-id <id>", "Payment ID").option("--reason <reason>", "Return reason").option("--reason-detail <text>", "Detailed reason").option("--refund-receipt-url <url>", "Refund receipt URL").option("--dry-run", "Validate inputs without executing").action(async (orderNumber, opts) => {
+  ret.command("refund <orderNumber>").description("Return with refund").requiredOption("--products <json>", "Return products array (JSON)").requiredOption("--refund-amount <n>", "Refund amount", parseFloat).requiredOption("--payment-id <id>", "Payment ID").option(
+    "--return-shipping-fee <n>",
+    "Return shipping fee charged to the customer",
+    parseFloat
+  ).option(
+    "--initial-shipping-refund-amount <n>",
+    "Initial order shipping refund amount",
+    parseFloat
+  ).option(
+    "--initial-shipping-refund-note <text>",
+    "Audit note for manual initial shipping refund override"
+  ).option("--reason <reason>", "Return reason").option("--reason-detail <text>", "Detailed reason").option("--refund-receipt-url <url>", "Refund receipt URL").option("--payment-key <key>", "Provider payment key").option("--dry-run", "Validate inputs without executing").action(async (orderNumber, opts) => {
     try {
-      const returnItems = parseWithSchema(
-        parseJsonArray(opts.products, "products"),
-        "products",
-        returnItemsSchema
-      );
-      const refundAmount = parseWithSchema(
-        opts.refundAmount,
-        "refund-amount",
-        refundAmountSchema
-      );
-      const reason = parseWithSchema(
-        opts.reason,
-        "reason",
-        returnReasonSchema
+      const data = parseWithSchema(
+        {
+          orderNumber,
+          returnItems: parseJsonArray(opts.products, "products"),
+          refundAmount: opts.refundAmount,
+          returnShippingFee: opts.returnShippingFee,
+          pgPaymentId: opts.paymentId,
+          reason: opts.reason,
+          reasonDetail: opts.reasonDetail,
+          refundReceiptUrl: opts.refundReceiptUrl,
+          paymentKey: opts.paymentKey,
+          initialShippingRefundAmount: opts.initialShippingRefundAmount,
+          initialShippingRefundOverrideNote: opts.initialShippingRefundNote
+        },
+        "return",
+        returnWithRefundSchema
       );
-      const data = {
-        orderNumber,
-        returnItems,
-        refundAmount,
-        pgPaymentId: opts.paymentId,
-        reason,
-        reasonDetail: opts.reasonDetail,
-        refundReceiptUrl: opts.refundReceiptUrl
-      };
       if (opts.dryRun) {
         printResult(
           { dryRun: true, valid: true, action: "return refund", data },
@@ -1109,7 +1785,7 @@ function registerReturnCommands(program2, getClient2, getFormat2) {
       const client = getClient2();
       const result = await client.commerce.orders.returnWithRefund({
         ...data,
-        returnItems
+        returnItems: data.returnItems
       });
       printResult(result, getFormat2());
     } catch (e) {
@@ -1190,6 +1866,60 @@ function registerCartCommands(program2, getClient2, getFormat2) {
       exitWithError(e);
     }
   });
+  cart.command("clear <cartId>").description("Remove all items from a cart").option("--dry-run", "Validate inputs without executing").action(async (cartId, opts) => {
+    try {
+      if (opts.dryRun) {
+        printResult(
+          { dryRun: true, valid: true, action: "cart clear", data: { cartId } },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.cart.clear({ cartId });
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
+  cart.command("apply-discount <cartId>").description("Apply a discount code to a cart").requiredOption("--code <code>", "Discount code").option("--dry-run", "Validate inputs without executing").action(async (cartId, opts) => {
+    try {
+      const data = { cartId, discountCode: opts.code };
+      if (opts.dryRun) {
+        printResult(
+          { dryRun: true, valid: true, action: "cart apply-discount", data },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.cart.applyDiscount(data);
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
+  cart.command("remove-discount <cartId>").description("Remove the discount from a cart").option("--dry-run", "Validate inputs without executing").action(async (cartId, opts) => {
+    try {
+      if (opts.dryRun) {
+        printResult(
+          {
+            dryRun: true,
+            valid: true,
+            action: "cart remove-discount",
+            data: { cartId }
+          },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.cart.removeDiscount({ cartId });
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
 }
 
 // src/commands/stock.ts
@@ -1211,19 +1941,50 @@ function registerStockCommands(program2, getClient2, getFormat2) {
 }
 
 // src/commands/transaction.ts
+import { z as z6 } from "zod";
+var transactionAmountSchema = z6.object({
+  amount: z6.string().regex(/^[1-9]\d*$/, "amount must be a positive integer").transform(Number)
+});
+var confirmPaymentAmountSchema = z6.object({
+  amount: z6.string().regex(/^(0|[1-9]\d*)$/, "amount must be a non-negative integer").transform(Number)
+});
+var idempotencyKeyOptionSchema = z6.object({
+  idempotencyKey: idempotencyKeySchema
+});
+function parseTransactionAmount(value) {
+  if (value === void 0) return void 0;
+  return parseWithSchema({ amount: value }, "amount", transactionAmountSchema).amount;
+}
+function parseConfirmPaymentAmount(value) {
+  return parseWithSchema({ amount: value }, "amount", confirmPaymentAmountSchema).amount;
+}
+function parseIdempotencyKey(value) {
+  if (value === void 0) return void 0;
+  return parseWithSchema(
+    { idempotencyKey: value },
+    "idempotencyKey",
+    idempotencyKeyOptionSchema
+  ).idempotencyKey;
+}
 function registerTransactionCommands(program2, getClient2, getFormat2) {
   const tx = program2.command("transaction").description("Transaction management");
   tx.command("update").description("Update transaction status").requiredOption("--payment-id <id>", "Payment ID").requiredOption(
     "--status <status>",
     "New status (pending, paid, failed, canceled)"
-  ).requiredOption("--payment-method <method>", "Payment method").requiredOption("--receipt-url <url>", "Receipt URL").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
+  ).option("--payment-method <method>", "Payment method").option("--receipt-url <url>", "Receipt URL").option("--payment-key <key>", "Provider payment key").option("--amount <n>", "Provider-confirmed amount").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
     try {
-      const data = {
-        pgPaymentId: opts.paymentId,
-        status: opts.status,
-        paymentMethod: opts.paymentMethod,
-        receiptUrl: opts.receiptUrl
-      };
+      const data = parseWithSchema(
+        {
+          pgPaymentId: opts.paymentId,
+          status: opts.status,
+          paymentMethod: opts.paymentMethod,
+          receiptUrl: opts.receiptUrl,
+          paymentKey: opts.paymentKey,
+          amount: parseTransactionAmount(opts.amount)
+        },
+        "transaction",
+        updateTransactionSchema
+      );
       if (opts.dryRun) {
         printResult(
           { dryRun: true, valid: true, action: "transaction update", data },
@@ -1238,6 +1999,132 @@ function registerTransactionCommands(program2, getClient2, getFormat2) {
       exitWithError(e);
     }
   });
+  tx.command("confirm-payment").description("Confirm a provider-verified payment for an order").requiredOption("--payment-id <id>", "Provider payment identifier (pgPaymentId)").requiredOption(
+    "--provider <slug>",
+    "Payment provider slug (toss, portone, stripe, ...)"
+  ).requiredOption(
+    "--amount <n>",
+    "Provider-confirmed amount in minor units"
+  ).option("--order-number <num>", "Order number").option("--pg-order-id <id>", "Provider order id").option("--currency <code>", "Currency code").option("--payment-method <method>", "Payment method").option("--receipt-url <url>", "Receipt URL").option("--approved-at <ts>", "Provider approval timestamp").option("--provider-status <status>", "Provider status").option("--provider-event-id <id>", "Provider event id (idempotency)").option("--idempotency-key <key>", "Idempotency key header override").option(
+    "--confirmation-source <src>",
+    "provider_webhook | provider_lookup | provider_api_confirm | manual_server"
+  ).option("--payment-key <key>", "Provider payment key").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
+    try {
+      const data = parseWithSchema(
+        {
+          pgPaymentId: opts.paymentId,
+          pgProvider: opts.provider,
+          amount: parseConfirmPaymentAmount(opts.amount),
+          ...opts.orderNumber ? { orderNumber: opts.orderNumber } : {},
+          ...opts.pgOrderId ? { pgOrderId: opts.pgOrderId } : {},
+          ...opts.currency ? { currency: opts.currency } : {},
+          ...opts.paymentMethod ? { paymentMethod: opts.paymentMethod } : {},
+          ...opts.receiptUrl ? { receiptUrl: opts.receiptUrl } : {},
+          ...opts.approvedAt ? { approvedAt: opts.approvedAt } : {},
+          ...opts.providerStatus ? { providerStatus: opts.providerStatus } : {},
+          ...opts.providerEventId ? { providerEventId: opts.providerEventId } : {},
+          ...opts.confirmationSource ? { confirmationSource: opts.confirmationSource } : {},
+          ...opts.paymentKey ? { paymentKey: opts.paymentKey } : {}
+        },
+        "confirm-payment",
+        confirmPaymentSchema
+      );
+      const sdkParams = {
+        ...data,
+        ...opts.idempotencyKey !== void 0 ? { idempotencyKey: parseIdempotencyKey(opts.idempotencyKey) } : {}
+      };
+      if (opts.dryRun) {
+        printResult(
+          {
+            dryRun: true,
+            valid: true,
+            action: "transaction confirm-payment",
+            data: sdkParams
+          },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.orders.confirmPayment(
+        sdkParams
+      );
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
+}
+
+// src/commands/product.ts
+function registerProductCommands(program2, getClient2, getFormat2) {
+  const product = program2.command("product").description("Product management");
+  product.command("upsert").description("Create or update a product graph (options, values, variants)").requiredOption("--input <json>", "Product upsert input (JSON)").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
+    try {
+      const data = parseWithSchema(
+        parseJson(opts.input, "input"),
+        "input",
+        ProductUpsertSchema
+      );
+      if (opts.dryRun) {
+        printResult(
+          { dryRun: true, valid: true, action: "product upsert", data },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.product.upsert(
+        data
+      );
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
+}
+
+// src/commands/discount.ts
+function registerDiscountCommands(program2, getClient2, getFormat2) {
+  const discount = program2.command("discount").description("Discount management");
+  discount.command("validate").description("Validate a discount code against an order amount").requiredOption("--code <code>", "Discount code").requiredOption(
+    "--order-amount <n>",
+    "Order amount",
+    (v) => parseInt(v, 10)
+  ).action(async (opts) => {
+    try {
+      const client = getClient2();
+      const result = await client.commerce.discounts.validate({
+        code: opts.code,
+        orderAmount: opts.orderAmount
+      });
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
+}
+
+// src/commands/shipping.ts
+function registerShippingCommands(program2, getClient2, getFormat2) {
+  const shipping = program2.command("shipping").description("Shipping calculation");
+  shipping.command("calculate").description("Calculate shipping for an order amount").requiredOption(
+    "--order-amount <n>",
+    "Order amount",
+    (v) => parseInt(v, 10)
+  ).option("--shipping-policy-id <id>", "Shipping policy ID").option("--postal-code <code>", "Destination postal code").action(async (opts) => {
+    try {
+      const client = getClient2();
+      const result = await client.commerce.shipping.calculate({
+        orderAmount: opts.orderAmount,
+        ...opts.shippingPolicyId ? { shippingPolicyId: opts.shippingPolicyId } : {},
+        ...opts.postalCode ? { postalCode: opts.postalCode } : {}
+      });
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
 }
 
 // src/commands/auth.ts
@@ -1332,7 +2219,7 @@ async function exchangeCode(code) {
   }
 }
 function startAuthServer(options) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve2, reject) => {
     const server = createServer((req, res) => {
       if (!req.url) {
         res.writeHead(400).end();
@@ -1407,7 +2294,7 @@ Logged in successfully!`));
         );
         cleanup(4);
       }, TIMEOUT_MS);
-      resolve3({ port: addr.port, cleanup });
+      resolve2({ port: addr.port, cleanup });
     });
     server.on("error", (err) => {
       reject(err);
@@ -1546,25 +2433,17 @@ ${loginUrl}`));
 }
 
 // src/commands/schema.ts
-import { COLLECTIONS as COLLECTIONS2 } from "@01.software/sdk";
+import { SERVER_COLLECTIONS as SERVER_COLLECTIONS2 } from "@01.software/sdk";
 function registerSchemaCommands(program2, getClient2, getFormat2) {
   const schema = program2.command("schema").description("Collection schema introspection");
   schema.command("list").description("List available collections").action(() => {
-    printResult(COLLECTIONS2, getFormat2());
+    printResult(SERVER_COLLECTIONS2, getFormat2());
   });
   schema.command("show <collection>").description("Show collection field schema").action(async (collection) => {
     try {
-      if (!COLLECTIONS2.includes(collection)) {
-        const normalized = collection.replace(/-/g, "").toLowerCase();
-        const suggestions = COLLECTIONS2.filter((c) => {
-          const cn = c.replace(/-/g, "").toLowerCase();
-          return cn.startsWith(normalized) || normalized.startsWith(cn) || normalized.length >= 3 && cn.includes(normalized);
-        }).slice(0, 5);
-        const hint = suggestions.length > 0 ? `Did you mean: ${suggestions.join(", ")}?` : 'Run "01 schema list" for available collections.';
-        throw new Error(`Unknown collection "${collection}". ${hint}`);
-      }
+      const col = validateCollection(collection);
       const client = getClient2();
-      const result = await client.tenant.collectionSchema(collection);
+      const result = await client.tenant.collectionSchema(col);
       printResult(result, getFormat2());
     } catch (e) {
       exitWithError(e);
@@ -1572,152 +2451,6 @@ function registerSchemaCommands(program2, getClient2, getFormat2) {
   });
 }
 
-// ../contracts/src/tenant/index.ts
-import { z as z3 } from "zod";
-var tenantFieldConfigStateSchema = z3.object({
-  hiddenFields: z3.array(z3.string()),
-  isHidden: z3.boolean()
-}).strict();
-var tenantContextQuerySchema = z3.object({
-  counts: z3.literal("true").optional()
-}).strict();
-var tenantContextToolInputSchema = z3.object({
-  includeCounts: z3.boolean().optional().default(false).describe(
-    "Include per-collection document counts and config status (bypasses cache, slower)"
-  )
-}).strict();
-var tenantContextResponseSchema = z3.object({
-  tenant: z3.object({
-    id: z3.string(),
-    name: z3.string(),
-    plan: z3.string(),
-    planSource: z3.string().optional(),
-    authoritative: z3.boolean().optional(),
-    capabilityVersion: z3.string().optional()
-  }).strict(),
-  features: z3.array(z3.string()),
-  collections: z3.object({
-    active: z3.array(z3.string()),
-    inactive: z3.array(z3.string())
-  }).strict(),
-  fieldConfigs: z3.record(z3.string(), tenantFieldConfigStateSchema),
-  counts: z3.record(z3.string(), z3.number()).optional(),
-  config: z3.object({
-    webhookConfigured: z3.boolean()
-  }).strict().optional()
-}).strict();
-var tenantFeatureProgressFeatureSchema = z3.enum(["ecommerce"]);
-var tenantFeatureProgressInputSchema = z3.object({
-  feature: tenantFeatureProgressFeatureSchema.describe(
-    "Feature to inspect for tenant implementation readiness"
-  ),
-  includeEvidence: z3.boolean().optional().default(false).describe("Include sanitized counts and static surface evidence")
-}).strict();
-var tenantFeatureProgressStatusSchema = z3.enum([
-  "ready",
-  "attention",
-  "blocked"
-]);
-var tenantFeatureProgressItemStateSchema = z3.enum([
-  "complete",
-  "incomplete",
-  "blocked",
-  "attention",
-  "optional",
-  "unknown",
-  "manual",
-  "not-applicable"
-]);
-var tenantFeatureProgressSeveritySchema = z3.enum([
-  "required",
-  "recommended",
-  "optional"
-]);
-var tenantFeatureProgressEvidenceValueSchema = z3.union([
-  z3.string(),
-  z3.number(),
-  z3.boolean(),
-  z3.null()
-]);
-var tenantFeatureProgressItemSchema = z3.object({
-  id: z3.string(),
-  title: z3.string(),
-  state: tenantFeatureProgressItemStateSchema,
-  severity: tenantFeatureProgressSeveritySchema,
-  summary: z3.string(),
-  evidence: z3.record(z3.string(), tenantFeatureProgressEvidenceValueSchema).optional()
-}).strict();
-var tenantFeatureProgressGroupSchema = z3.object({
-  id: z3.string(),
-  title: z3.string(),
-  summary: z3.string().optional(),
-  items: z3.array(tenantFeatureProgressItemSchema)
-}).strict();
-var tenantFeatureProgressResponseSchema = z3.object({
-  schemaVersion: z3.literal(1),
-  feature: tenantFeatureProgressFeatureSchema,
-  status: tenantFeatureProgressStatusSchema,
-  generatedAt: z3.string(),
-  tenant: z3.object({
-    id: z3.string(),
-    name: z3.string(),
-    plan: z3.string()
-  }).strict(),
-  capability: z3.object({
-    effectiveFeatures: z3.array(z3.string()),
-    planBlocked: z3.array(z3.string()),
-    closureAdded: z3.array(z3.string())
-  }).strict(),
-  summary: z3.object({
-    complete: z3.number().int().nonnegative(),
-    total: z3.number().int().nonnegative(),
-    blocking: z3.number().int().nonnegative(),
-    manual: z3.number().int().nonnegative(),
-    unknown: z3.number().int().nonnegative()
-  }).strict(),
-  groups: z3.array(tenantFeatureProgressGroupSchema)
-}).strict();
-var COLLECTION_SCHEMA_CONTRACT_VERSION = 1;
-var collectionSchemaEndpointParamsSchema = z3.object({
-  collectionSlug: z3.string().min(1, "collectionSlug is required")
-}).strict();
-var collectionFieldOptionSchema = z3.object({
-  label: z3.string(),
-  value: z3.string()
-}).strict();
-var collectionFieldSchema = z3.lazy(
-  () => z3.object({
-    name: z3.string(),
-    path: z3.string(),
-    type: z3.string(),
-    required: z3.literal(true).optional(),
-    unique: z3.literal(true).optional(),
-    hasMany: z3.literal(true).optional(),
-    relationTo: z3.union([z3.string(), z3.array(z3.string())]).optional(),
-    options: z3.array(collectionFieldOptionSchema).optional(),
-    hidden: z3.literal(true).optional(),
-    systemManaged: z3.literal(true).optional(),
-    writable: z3.boolean().optional(),
-    fields: z3.array(collectionFieldSchema).optional()
-  }).strict()
-);
-var collectionSchemaResponseSchema = z3.object({
-  contractVersion: z3.literal(COLLECTION_SCHEMA_CONTRACT_VERSION),
-  mode: z3.literal("effective"),
-  collection: z3.object({
-    slug: z3.string(),
-    timestamps: z3.boolean(),
-    alwaysActive: z3.boolean(),
-    feature: z3.string().nullable(),
-    systemFields: z3.array(z3.string()),
-    visibility: z3.object({
-      collectionHidden: z3.boolean(),
-      hiddenFields: z3.array(z3.string())
-    }).strict(),
-    fields: z3.array(collectionFieldSchema)
-  }).strict()
-}).strict();
-
 // src/commands/feature.ts
 function flattenProgress(progress) {
   return progress.groups.flatMap(
@@ -1757,98 +2490,8 @@ function registerFeatureCommands(program2, getClient2, getFormat2) {
   });
 }
 
-// src/commands/mcp.ts
-import { resolve, dirname } from "path";
-import { existsSync as existsSync2 } from "fs";
-import { spawn } from "child_process";
-import { fileURLToPath } from "url";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-function getStdioEntryCandidates(baseDir = __dirname) {
-  const candidates = [
-    {
-      label: "packaged CLI artifact",
-      path: resolve(baseDir, "mcp/stdio.js")
-    }
-  ];
-  const roots = ["../../../..", "../../..", "../.."];
-  const entries = [
-    {
-      label: "monorepo build output",
-      path: "apps/mcp/dist/stdio.js"
-    },
-    {
-      label: "xmcp build output",
-      path: "apps/mcp/.xmcp/stdio.js"
-    }
-  ];
-  for (const entry of entries) {
-    for (const root of roots) {
-      candidates.push({
-        label: entry.label,
-        path: resolve(baseDir, root, entry.path)
-      });
-    }
-  }
-  return candidates;
-}
-function findStdioEntry(baseDir = __dirname) {
-  for (const candidate of getStdioEntryCandidates(baseDir)) {
-    if (existsSync2(candidate.path)) return candidate.path;
-  }
-  return null;
-}
-function formatMissingStdioEntryMessage(baseDir = __dirname) {
-  const checked = getStdioEntryCandidates(baseDir).map((candidate) => `  - ${candidate.label}: ${candidate.path}`).join("\n");
-  return [
-    "MCP stdio entry not found.",
-    "Checked:",
-    checked,
-    "Fix:",
-    "  - Monorepo checkout: run pnpm --filter mcp build.",
-    "  - Published CLI: reinstall or update @01.software/cli so dist/mcp/stdio.js is included."
-  ].join("\n");
-}
-function createMcpEnv(baseEnv, client) {
-  const env = {
-    ...baseEnv,
-    SOFTWARE_PUBLISHABLE_KEY: client.publishableKey,
-    SOFTWARE_SECRET_KEY: client.secretKey
-  };
-  delete env.SOFTWARE_TENANT_ID;
-  return env;
-}
-function registerMcpCommands(program2) {
-  program2.command("mcp").description("Start local MCP stdio server for trusted server-key workflows").addHelpText(
-    "after",
-    `
-Prerequisites:
-  Run 01 login, or set SOFTWARE_PUBLISHABLE_KEY and SOFTWARE_SECRET_KEY.
-  Local stdio exposes the full MCP tool surface; HTTP OAuth MCP uses the
-  narrower remote surface documented in the web integration guide.
-  In a monorepo checkout, build the stdio artifact first:
-    pnpm --filter mcp build
-`
-  ).action(() => {
-    const client = resolveClient(program2.opts().apiKey);
-    const stdioEntry = findStdioEntry();
-    if (!stdioEntry) {
-      exitWithError(new Error(formatMissingStdioEntryMessage()));
-    }
-    const child = spawn(process.execPath, [stdioEntry], {
-      env: createMcpEnv(process.env, client),
-      stdio: ["inherit", "inherit", "inherit"]
-    });
-    child.on("error", (err) => {
-      exitWithError(new Error(`Failed to start MCP server: ${err.message}`));
-    });
-    child.on("exit", (code) => {
-      process.exit(code ?? 0);
-    });
-  });
-}
-
 // src/commands/agent.ts
-import { COLLECTIONS as COLLECTIONS3 } from "@01.software/sdk";
+import { SERVER_COLLECTIONS as SERVER_COLLECTIONS3 } from "@01.software/sdk";
 
 // src/lib/agent-output.ts
 var PLAN_AGENT_ERROR_CODES = /* @__PURE__ */ new Set([
@@ -2012,7 +2655,7 @@ function hashAgentPlanEnvelope(input) {
 }
 
 // src/lib/agent-plan-id.ts
-import { resolve as resolve2, sep } from "path";
+import { resolve, sep } from "path";
 var PLAN_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function assertValidPlanId(planId) {
   if (!PLAN_ID_PATTERN.test(planId)) {
@@ -2021,8 +2664,8 @@ function assertValidPlanId(planId) {
 }
 function safePlanPath(planDir, planId) {
   assertValidPlanId(planId);
-  const resolvedDir = resolve2(planDir);
-  const resolvedPath = resolve2(resolvedDir, `${planId}.json`);
+  const resolvedDir = resolve(planDir);
+  const resolvedPath = resolve(resolvedDir, `${planId}.json`);
   if (resolvedPath !== resolvedDir && !resolvedPath.startsWith(`${resolvedDir}${sep}`)) {
     throw agentPlanError("INVALID_INPUT", "Invalid plan token.");
   }
@@ -2633,7 +3276,10 @@ function parseWhere(value) {
   }
   throw invalidInput2("--where must be a JSON object", "where", value);
 }
-var AGENT_READ_OPERATIONS = ["query", "get"];
+var AGENT_READ_OPERATIONS = [
+  "query",
+  "get"
+];
 var AGENT_PLAN_OPERATIONS = [
   "plan:create",
   "plan:update",
@@ -2641,7 +3287,7 @@ var AGENT_PLAN_OPERATIONS = [
 ];
 function buildAgentManifest() {
   const collections = {};
-  for (const collection of COLLECTIONS3) {
+  for (const collection of SERVER_COLLECTIONS3) {
     const operations = isAgentPlanCollection(collection) ? [...AGENT_READ_OPERATIONS, ...AGENT_PLAN_OPERATIONS] : [...AGENT_READ_OPERATIONS];
     collections[collection] = {
       operations,
@@ -2670,7 +3316,9 @@ function registerAgentCommands(program2, getClient2) {
   );
   configureAgentParser2(
     agent.command("manifest").description("Print the Agent CLI protocol manifest").option("--pretty", "Print 2-space indented JSON").action((opts) => {
-      printAgentSuccess(buildAgentManifest(), { pretty: Boolean(opts.pretty) });
+      printAgentSuccess(buildAgentManifest(), {
+        pretty: Boolean(opts.pretty)
+      });
     })
   );
   configureAgentParser2(
@@ -2741,9 +3389,11 @@ registerReturnCommands(program, getClient, getFormat);
 registerCartCommands(program, getClient, getFormat);
 registerStockCommands(program, getClient, getFormat);
 registerTransactionCommands(program, getClient, getFormat);
+registerProductCommands(program, getClient, getFormat);
+registerDiscountCommands(program, getClient, getFormat);
+registerShippingCommands(program, getClient, getFormat);
 registerSchemaCommands(program, getClient, getFormat);
 registerFeatureCommands(program, getClient, getFormat);
-registerMcpCommands(program);
 registerAuthCommands(program);
 program.parse();
 //# sourceMappingURL=index.js.map