@aglyn/plugins-commerce 1.0.0-beta.221 → 1.0.0-beta.223

package/src/lib/transfer/product-transfer.js

@@ -0,0 +1,1594 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { buildTransferPlan, isBlankTransferValue, TRANSFER_SYSTEM_GROUP, TRANSFER_WARNING_CLASSES } from "@aglyn/aglyn/data-transfer";
+import { COMMERCE_MAX_VARIANTS, COMMERCE_SLUG_MAX_LENGTH, commerceSlug, productInventory, productPriceRange, validateProduct } from "../model/commerce.js";
+/*
+ * PRODUCTS ON THE TRANSFER FRAMEWORK (AGL-3531).
+ *
+ * ## One product, one row per variant
+ *
+ * A product's file is laid out the way storefront platforms lay theirs out:
+ * a row per variant, the product's own fields (title, description, tags…)
+ * on its first row, and every row carrying the product's handle. Images
+ * follow the same convention — the first on the first row, the next on the
+ * second, and rows of only a handle and an image when there are more images
+ * than variants. So a store moving here from Shopify uploads its own export
+ * as it is, and the Shopify preset writes one Shopify reads back.
+ *
+ * ## Rows fold into products
+ *
+ * The engine plans rows; a product is several. `planProductTransfer` (this
+ * resource's `plan` hook) folds the rows of one handle into one product: the
+ * first row decides whether the product is new or which one it is (by
+ * handle, then SKU, then ID — the person's order), its product fields are
+ * planned against the product, and every row's variant fields are planned
+ * against the variant it names — by SKU, then by its option values, then the
+ * single variant of a single-variant product. A match is UPDATED; the old
+ * importer created a second product under a suffixed slug.
+ *
+ * Every row keeps its own verdict and diff, so the dry run shows what each
+ * line of the file does, and the plan stashes what the apply needs on the
+ * row (`commerce`): the product's id — minted here for a new one, so a retry
+ * finds what it already wrote — the variant's, and for a new product the
+ * whole document.
+ *
+ * ## What a file never sets
+ *
+ * Option names already on a product (renaming one moves every variant, which
+ * the product editor does), stock kept by location (moved per location), and
+ * the search, stock and collection keys every write derives.
+ */ /*==========================================
+ * FIELDS
+ *=========================================*/ /** The field ids, as the catalog and every file name them. */ export const PRODUCT_FIELD = {
+    handle: 'handle',
+    title: 'title',
+    description: 'description',
+    kind: 'type',
+    status: 'status',
+    published: 'published',
+    tags: 'tags',
+    categories: 'categories',
+    option1Name: 'option1Name',
+    option2Name: 'option2Name',
+    option3Name: 'option3Name',
+    image: 'image',
+    seoTitle: 'seoTitle',
+    seoDescription: 'seoDescription',
+    taxExempt: 'taxExempt',
+    oversellPolicy: 'oversellPolicy',
+    lowStockThreshold: 'lowStockThreshold',
+    option1Value: 'option1Value',
+    option2Value: 'option2Value',
+    option3Value: 'option3Value',
+    sku: 'sku',
+    barcode: 'barcode',
+    price: 'price',
+    compareAtPrice: 'compareAtPrice',
+    inventory: 'inventory',
+    weightGrams: 'weightGrams',
+    variantImage: 'variantImage',
+    priceFrom: 'priceFrom',
+    totalInventory: 'totalInventory',
+    soldOut: 'soldOut',
+    variantCount: 'variantCount',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+};
+const F = PRODUCT_FIELD;
+/** The picklists the product fields name. */ export const PRODUCT_KIND_PICKLIST = 'commerce.productKind';
+export const PRODUCT_STATUS_PICKLIST = 'commerce.productStatus';
+export const PRODUCT_OVERSELL_PICKLIST = 'commerce.oversellPolicy';
+export const PRODUCT_CATEGORY_PICKLIST = 'commerce.categories';
+const KIND_LABELS = {
+    physical: 'Physical',
+    digital: 'Digital',
+    service: 'Service'
+};
+const STATUS_LABELS = {
+    active: 'Active',
+    draft: 'Draft',
+    archived: 'Archived'
+};
+const OVERSELL_LABELS = {
+    deny: 'Stop selling',
+    backorder: 'Keep selling'
+};
+/** A fixed list as the values step matches it: a file adds nothing to it. */ function fixedList(labels, defaultValueId) {
+    return {
+        restricted: true,
+        standardValues: Object.entries(labels).map(([id, label])=>({
+                id,
+                label
+            })),
+        defaultValueId
+    };
+}
+/** The fixed lists products name, by picklist id. */ export const PRODUCT_FIXED_PICKLISTS = {
+    [PRODUCT_KIND_PICKLIST]: fixedList(KIND_LABELS, 'physical'),
+    [PRODUCT_STATUS_PICKLIST]: fixedList(STATUS_LABELS, 'active'),
+    [PRODUCT_OVERSELL_PICKLIST]: fixedList(OVERSELL_LABELS, 'deny')
+};
+/** The id a label of a fixed list names, by label or id in any case; `null` for none. */ export function fixedListId(picklistId, value) {
+    const spec = PRODUCT_FIXED_PICKLISTS[picklistId];
+    const key = String(value != null ? value : '').trim().toLowerCase();
+    if (!spec || !key) return null;
+    const found = spec.standardValues.find((entry)=>entry.id.toLowerCase() === key || entry.label.toLowerCase() === key);
+    return found ? found.id : null;
+}
+/** A fixed list's label for a stored id. */ function fixedListLabel(picklistId, id) {
+    var _ref;
+    var _spec_standardValues_find;
+    const spec = PRODUCT_FIXED_PICKLISTS[picklistId];
+    return (_ref = spec == null ? void 0 : (_spec_standardValues_find = spec.standardValues.find((entry)=>entry.id === id)) == null ? void 0 : _spec_standardValues_find.label) != null ? _ref : null;
+}
+export const PRODUCT_TRANSFER_GROUPS = [
+    {
+        id: 'product',
+        label: 'Product'
+    },
+    {
+        id: 'variant',
+        label: 'Variant'
+    },
+    {
+        id: 'options',
+        label: 'Options'
+    },
+    {
+        id: 'media',
+        label: 'Images'
+    },
+    {
+        id: 'selling',
+        label: 'Selling'
+    },
+    {
+        id: 'seo',
+        label: 'Search listing'
+    },
+    {
+        id: 'computed',
+        label: 'Computed'
+    }
+];
+/** The fields a product's first row carries: the product's own. */ export const PRODUCT_LEVEL_FIELDS = [
+    F.handle,
+    F.title,
+    F.description,
+    F.kind,
+    F.status,
+    F.published,
+    F.tags,
+    F.categories,
+    F.option1Name,
+    F.option2Name,
+    F.option3Name,
+    F.image,
+    F.seoTitle,
+    F.seoDescription,
+    F.taxExempt,
+    F.oversellPolicy,
+    F.lowStockThreshold
+];
+/** The fields every row carries for its own variant. */ export const VARIANT_LEVEL_FIELDS = [
+    F.option1Value,
+    F.option2Value,
+    F.option3Value,
+    F.sku,
+    F.barcode,
+    F.price,
+    F.compareAtPrice,
+    F.inventory,
+    F.weightGrams,
+    F.variantImage
+];
+const OPTION_NAME_FIELDS = [
+    F.option1Name,
+    F.option2Name,
+    F.option3Name
+];
+const OPTION_VALUE_FIELDS = [
+    F.option1Value,
+    F.option2Value,
+    F.option3Value
+];
+/** Every writable product field, in picker order. */ export const PRODUCT_STANDARD_FIELDS = [
+    {
+        id: F.handle,
+        label: 'Handle',
+        group: 'product',
+        type: 'text',
+        maxLength: 80,
+        aliases: [
+            'slug',
+            'url handle',
+            'product handle'
+        ],
+        description: 'The product’s address, /products/<handle>. Rows with one handle are one product.'
+    },
+    {
+        id: F.title,
+        label: 'Title',
+        group: 'product',
+        type: 'text',
+        aliases: [
+            'name',
+            'product name',
+            'product title'
+        ],
+        description: 'Needed for a new product.'
+    },
+    {
+        id: F.description,
+        label: 'Description',
+        group: 'product',
+        type: 'longText',
+        aliases: [
+            'body',
+            'body html',
+            'product description',
+            'description html'
+        ]
+    },
+    {
+        id: F.kind,
+        label: 'Kind',
+        group: 'product',
+        type: 'picklist',
+        picklistId: PRODUCT_KIND_PICKLIST,
+        aliases: [
+            'product kind',
+            'type'
+        ],
+        description: 'Physical, Digital or Service.'
+    },
+    {
+        id: F.status,
+        label: 'Status',
+        group: 'product',
+        type: 'picklist',
+        picklistId: PRODUCT_STATUS_PICKLIST,
+        aliases: [
+            'product status'
+        ],
+        description: 'Active, Draft or Archived.'
+    },
+    {
+        id: F.published,
+        label: 'Published',
+        group: 'product',
+        type: 'boolean',
+        aliases: [
+            'visible',
+            'online'
+        ],
+        description: 'Read as the status when the file has no Status: yes is Active, no is Draft.'
+    },
+    {
+        id: F.tags,
+        label: 'Tags',
+        group: 'product',
+        type: 'text',
+        aliases: [
+            'tag',
+            'keywords'
+        ],
+        description: 'Separated by commas; their case is kept, because collections match a tag exactly.'
+    },
+    {
+        id: F.categories,
+        label: 'Categories',
+        group: 'product',
+        type: 'multiPicklist',
+        picklistId: PRODUCT_CATEGORY_PICKLIST,
+        aliases: [
+            'category',
+            'product categories'
+        ],
+        description: 'By name. A name the site does not have can be added as a new category.'
+    },
+    {
+        id: F.option1Name,
+        label: 'Option 1 name',
+        group: 'options',
+        type: 'text',
+        maxLength: 60
+    },
+    {
+        id: F.option1Value,
+        label: 'Option 1 value',
+        group: 'options',
+        type: 'text',
+        maxLength: 60
+    },
+    {
+        id: F.option2Name,
+        label: 'Option 2 name',
+        group: 'options',
+        type: 'text',
+        maxLength: 60
+    },
+    {
+        id: F.option2Value,
+        label: 'Option 2 value',
+        group: 'options',
+        type: 'text',
+        maxLength: 60
+    },
+    {
+        id: F.option3Name,
+        label: 'Option 3 name',
+        group: 'options',
+        type: 'text',
+        maxLength: 60
+    },
+    {
+        id: F.option3Value,
+        label: 'Option 3 value',
+        group: 'options',
+        type: 'text',
+        maxLength: 60
+    },
+    {
+        id: F.sku,
+        label: 'SKU',
+        group: 'variant',
+        type: 'text',
+        aliases: [
+            'variant sku',
+            'stock keeping unit',
+            'item number'
+        ]
+    },
+    {
+        id: F.barcode,
+        label: 'Barcode',
+        group: 'variant',
+        type: 'text',
+        aliases: [
+            'variant barcode',
+            'gtin',
+            'upc',
+            'ean',
+            'isbn'
+        ]
+    },
+    {
+        id: F.price,
+        label: 'Price',
+        group: 'variant',
+        type: 'currency',
+        aliases: [
+            'variant price',
+            'price usd',
+            'unit price'
+        ],
+        description: 'In US dollars. Needed for a new variant.'
+    },
+    {
+        id: F.compareAtPrice,
+        label: 'Compare-at price',
+        group: 'variant',
+        type: 'currency',
+        aliases: [
+            'variant compare at price',
+            'compare at price',
+            'was price',
+            'original price'
+        ],
+        description: 'The strike-through price; above the price, or a product is refused.'
+    },
+    {
+        id: F.inventory,
+        label: 'Inventory',
+        group: 'variant',
+        type: 'integer',
+        aliases: [
+            'variant inventory qty',
+            'inventory quantity',
+            'quantity',
+            'stock',
+            'on hand'
+        ],
+        description: 'Units in stock; blank is not counted. Stock kept by location is changed on the products page.'
+    },
+    {
+        id: F.weightGrams,
+        label: 'Weight (grams)',
+        group: 'variant',
+        type: 'number',
+        aliases: [
+            'variant grams',
+            'grams',
+            'weight'
+        ]
+    },
+    {
+        id: F.variantImage,
+        label: 'Variant image',
+        group: 'variant',
+        type: 'url',
+        aliases: [
+            'variant image url'
+        ]
+    },
+    {
+        id: F.image,
+        label: 'Image',
+        group: 'media',
+        type: 'url',
+        aliases: [
+            'image url',
+            'image src',
+            'photo',
+            'picture'
+        ],
+        description: 'One image per row; the first row’s is the photo the storefront leads with.'
+    },
+    {
+        id: F.seoTitle,
+        label: 'SEO title',
+        group: 'seo',
+        type: 'text',
+        aliases: [
+            'meta title',
+            'page title',
+            'search title'
+        ]
+    },
+    {
+        id: F.seoDescription,
+        label: 'SEO description',
+        group: 'seo',
+        type: 'longText',
+        aliases: [
+            'meta description',
+            'search description'
+        ]
+    },
+    {
+        id: F.taxExempt,
+        label: 'Tax exempt',
+        group: 'selling',
+        type: 'boolean',
+        aliases: [
+            'tax free',
+            'no tax'
+        ]
+    },
+    {
+        id: F.oversellPolicy,
+        label: 'When sold out',
+        group: 'selling',
+        type: 'picklist',
+        picklistId: PRODUCT_OVERSELL_PICKLIST,
+        aliases: [
+            'oversell policy',
+            'inventory policy',
+            'backorders'
+        ],
+        description: 'Stop selling, or Keep selling as a backorder.'
+    },
+    {
+        id: F.lowStockThreshold,
+        label: 'Low stock alert at',
+        group: 'selling',
+        type: 'integer',
+        aliases: [
+            'low stock threshold',
+            'reorder point'
+        ]
+    }
+];
+export const PRODUCT_DERIVED_FIELDS = [
+    {
+        id: F.priceFrom,
+        label: 'Lowest price',
+        group: 'computed',
+        type: 'number'
+    },
+    {
+        id: F.totalInventory,
+        label: 'Total inventory',
+        group: 'computed',
+        type: 'integer'
+    },
+    {
+        id: F.soldOut,
+        label: 'Sold out',
+        group: 'computed',
+        type: 'boolean'
+    },
+    {
+        id: F.variantCount,
+        label: 'Variants',
+        group: 'computed',
+        type: 'integer'
+    }
+];
+export const PRODUCT_SYSTEM_FIELDS = [
+    {
+        id: F.createdAt,
+        label: 'Created',
+        group: TRANSFER_SYSTEM_GROUP.id,
+        type: 'datetime'
+    },
+    {
+        id: F.updatedAt,
+        label: 'Updated',
+        group: TRANSFER_SYSTEM_GROUP.id,
+        type: 'datetime'
+    }
+];
+/** Handle, then SKU, then the Aglyn ID. */ export const PRODUCT_MATCH_KEYS = [
+    {
+        fieldId: F.handle,
+        normalizer: 'slug'
+    },
+    {
+        fieldId: F.sku,
+        normalizer: 'caseless'
+    },
+    {
+        fieldId: 'id',
+        normalizer: 'aglynId'
+    }
+];
+/**
+ * A product's handle and its option names are changed in the product editor,
+ * never by a file: the handle is the product's address, and renaming an
+ * option moves every variant. A file gives a new product both, and names an
+ * option a product does not have yet.
+ */ export const PRODUCT_LOCKED_RULES = [
+    {
+        fieldId: F.handle,
+        reason: 'A product’s handle is its address; a file gives a new product one, and an existing product’s is changed in the product editor.',
+        forced: {
+            mode: 'fillBlanks',
+            blank: 'leave'
+        }
+    },
+    ...OPTION_NAME_FIELDS.map((fieldId)=>({
+            fieldId,
+            reason: 'An option a product already has is renamed in the product editor, where every variant moves with it; a file only names an option the product does not have yet.',
+            forced: {
+                mode: 'fillBlanks',
+                blank: 'leave'
+            }
+        }))
+];
+/*==========================================
+ * THE SHOPIFY LAYOUT
+ *=========================================*/ /** Shopify's product CSV columns, by the field each one means. */ export const SHOPIFY_PRODUCT_COLUMNS = {
+    [F.handle]: 'Handle',
+    [F.title]: 'Title',
+    [F.description]: 'Body (HTML)',
+    [F.tags]: 'Tags',
+    [F.published]: 'Published',
+    [F.option1Name]: 'Option1 Name',
+    [F.option1Value]: 'Option1 Value',
+    [F.option2Name]: 'Option2 Name',
+    [F.option2Value]: 'Option2 Value',
+    [F.option3Name]: 'Option3 Name',
+    [F.option3Value]: 'Option3 Value',
+    [F.sku]: 'Variant SKU',
+    [F.weightGrams]: 'Variant Grams',
+    [F.inventory]: 'Variant Inventory Qty',
+    [F.oversellPolicy]: 'Variant Inventory Policy',
+    [F.price]: 'Variant Price',
+    [F.compareAtPrice]: 'Variant Compare At Price',
+    [F.barcode]: 'Variant Barcode',
+    [F.image]: 'Image Src',
+    [F.seoTitle]: 'SEO Title',
+    [F.seoDescription]: 'SEO Description',
+    [F.variantImage]: 'Variant Image',
+    [F.status]: 'Status'
+};
+/** Shopify's export headers, so its file maps column for column. */ export const PRODUCT_ALIAS_DICTIONARIES = [
+    {
+        source: 'Shopify',
+        aliases: Object.fromEntries(Object.entries(SHOPIFY_PRODUCT_COLUMNS).map(([fieldId, column])=>[
+                fieldId,
+                [
+                    column
+                ]
+            ]))
+    }
+];
+/**
+ * The Shopify preset: Shopify's product CSV columns, in Shopify's order and
+ * under Shopify's names. Status is left out — Shopify reads it in lowercase
+ * and Published says the same thing — and so is the kind, which Shopify's
+ * "Type" does not mean.
+ */ export const SHOPIFY_PRODUCT_PRESET = {
+    id: 'shopify',
+    label: 'Shopify',
+    description: 'Shopify’s product CSV: its columns, its order and its names.',
+    fieldIds: [
+        F.handle,
+        F.title,
+        F.description,
+        F.tags,
+        F.published,
+        F.option1Name,
+        F.option1Value,
+        F.option2Name,
+        F.option2Value,
+        F.option3Name,
+        F.option3Value,
+        F.sku,
+        F.weightGrams,
+        F.inventory,
+        F.oversellPolicy,
+        F.price,
+        F.compareAtPrice,
+        F.barcode,
+        F.image,
+        F.seoTitle,
+        F.seoDescription,
+        F.variantImage
+    ],
+    headers: Object.fromEntries(Object.entries(SHOPIFY_PRODUCT_COLUMNS).filter(([fieldId])=>fieldId !== F.status))
+};
+/*==========================================
+ * A PRODUCT AS RECORDS
+ *=========================================*/ /** Where a product's record keeps its variants, apart from its fields. */ export const PRODUCT_VARIANT_ORDER = '$variants';
+/** The record key one variant's values live under. */ export function productVariantKey(variantId) {
+    return `$variant:${variantId}`;
+}
+const isoOf = (value, ms)=>{
+    const time = typeof ms === 'number' ? ms : value && typeof value.toMillis === 'function' ? value.toMillis() : typeof value === 'number' ? value : null;
+    return time === null || !Number.isFinite(time) ? null : new Date(time).toISOString();
+};
+/** One variant as a file names it. */ export function variantRecord(variant, options) {
+    var _variant_sku, _variant_barcode, _variant_compareAtPriceUsd, _variant_weightGrams, _variant_imageUrl;
+    const values = {
+        [F.sku]: (_variant_sku = variant.sku) != null ? _variant_sku : null,
+        [F.barcode]: (_variant_barcode = variant.barcode) != null ? _variant_barcode : null,
+        [F.price]: Number.isFinite(Number(variant.priceUsd)) ? Number(variant.priceUsd) : null,
+        [F.compareAtPrice]: (_variant_compareAtPriceUsd = variant.compareAtPriceUsd) != null ? _variant_compareAtPriceUsd : null,
+        [F.inventory]: typeof variant.inventory === 'number' ? variant.inventory : null,
+        [F.weightGrams]: (_variant_weightGrams = variant.weightGrams) != null ? _variant_weightGrams : null,
+        [F.variantImage]: (_variant_imageUrl = variant.imageUrl) != null ? _variant_imageUrl : null
+    };
+    OPTION_VALUE_FIELDS.forEach((fieldId, axis)=>{
+        var _ref;
+        var _options_axis, _variant_options;
+        const name = (_options_axis = options[axis]) == null ? void 0 : _options_axis.name;
+        values[fieldId] = name ? (_ref = (_variant_options = variant.options) == null ? void 0 : _variant_options[name]) != null ? _ref : null : null;
+    });
+    if (variant.inventoryByLocation && Object.keys(variant.inventoryByLocation).length) values.$byLocation = true;
+    return values;
+}
+/**
+ * A product as one record: its fields by field id, and its variants under
+ * {@link productVariantKey} in the order {@link PRODUCT_VARIANT_ORDER} lists
+ * them. The lookup answers this shape, so the dry run's before → after and
+ * undo's "edited since" both read a product the way a file names it.
+ */ export function productRecord(stored, categoryNames = new Map()) {
+    var _product_options, _product_slug, _product_name, _product_description, _product_type, _product_status, _product_status1, _product_categoryIds, _ref, _ref1, _product_taxExempt, _product_oversellPolicy, _product_lowStockThreshold;
+    var _product_tags, _product_mediaUrls, _product_seo, _product_seo1;
+    const product = stored;
+    const options = (_product_options = product.options) != null ? _product_options : [];
+    const variants = Array.isArray(product.variants) ? product.variants : [];
+    const [low] = variants.length ? productPriceRange(product) : [
+        null
+    ];
+    const total = variants.length ? productInventory(product) : null;
+    const record = {
+        [F.handle]: (_product_slug = product.slug) != null ? _product_slug : null,
+        [F.title]: (_product_name = product.name) != null ? _product_name : null,
+        [F.description]: (_product_description = product.description) != null ? _product_description : null,
+        [F.kind]: fixedListLabel(PRODUCT_KIND_PICKLIST, (_product_type = product.type) != null ? _product_type : 'physical'),
+        [F.status]: fixedListLabel(PRODUCT_STATUS_PICKLIST, (_product_status = product.status) != null ? _product_status : 'active'),
+        [F.published]: ((_product_status1 = product.status) != null ? _product_status1 : 'active') === 'active',
+        [F.tags]: ((_product_tags = product.tags) == null ? void 0 : _product_tags.length) ? product.tags.join(', ') : null,
+        [F.categories]: ((_product_categoryIds = product.categoryIds) != null ? _product_categoryIds : []).map((id)=>{
+            var _categoryNames_get;
+            return (_categoryNames_get = categoryNames.get(id)) != null ? _categoryNames_get : id;
+        }),
+        [F.image]: ((_product_mediaUrls = product.mediaUrls) == null ? void 0 : _product_mediaUrls.length) ? [
+            ...product.mediaUrls
+        ] : product.imageUrl ? [
+            product.imageUrl
+        ] : [],
+        [F.seoTitle]: (_ref = (_product_seo = product.seo) == null ? void 0 : _product_seo.title) != null ? _ref : null,
+        [F.seoDescription]: (_ref1 = (_product_seo1 = product.seo) == null ? void 0 : _product_seo1.description) != null ? _ref1 : null,
+        [F.taxExempt]: (_product_taxExempt = product.taxExempt) != null ? _product_taxExempt : null,
+        [F.oversellPolicy]: fixedListLabel(PRODUCT_OVERSELL_PICKLIST, (_product_oversellPolicy = product.oversellPolicy) != null ? _product_oversellPolicy : 'deny'),
+        [F.lowStockThreshold]: (_product_lowStockThreshold = product.lowStockThreshold) != null ? _product_lowStockThreshold : null,
+        [F.priceFrom]: low,
+        [F.totalInventory]: total,
+        [F.soldOut]: total !== null && total <= 0 && product.oversellPolicy !== 'backorder',
+        [F.variantCount]: variants.length,
+        [F.createdAt]: isoOf(stored.createdAt, stored.createdAtMs),
+        [F.updatedAt]: isoOf(stored.updatedAt, stored.updatedAtMs),
+        [PRODUCT_VARIANT_ORDER]: variants.map((variant)=>variant.id)
+    };
+    OPTION_NAME_FIELDS.forEach((fieldId, axis)=>{
+        var _ref;
+        var _options_axis;
+        record[fieldId] = (_ref = (_options_axis = options[axis]) == null ? void 0 : _options_axis.name) != null ? _ref : null;
+    });
+    for (const variant of variants)record[productVariantKey(variant.id)] = variantRecord(variant, options);
+    return record;
+}
+/**
+ * A product's rows in a file, holding only `fieldIds`: one per variant (and
+ * per image past the variants), the product's own fields on the first, the
+ * handle and the ID on every one.
+ */ export function productExportRows(id, stored, fieldIds, categoryNames = new Map()) {
+    const record = productRecord(stored, categoryNames);
+    const variantIds = record[PRODUCT_VARIANT_ORDER];
+    const images = record[F.image];
+    const count = Math.max(1, variantIds.length, images.length);
+    const variantFields = new Set(VARIANT_LEVEL_FIELDS);
+    const rows = [];
+    for(let index = 0; index < count; index += 1){
+        const variantId = variantIds[index];
+        const variant = variantId ? record[productVariantKey(variantId)] : null;
+        const row = {};
+        for (const fieldId of fieldIds){
+            var _images_index, _variant_fieldId, _record_fieldId;
+            if (fieldId === 'id') row[fieldId] = id;
+            else if (fieldId === F.handle) row[fieldId] = record[F.handle];
+            else if (fieldId === F.image) row[fieldId] = (_images_index = images[index]) != null ? _images_index : null;
+            else if (variantFields.has(fieldId)) row[fieldId] = variant ? (_variant_fieldId = variant[fieldId]) != null ? _variant_fieldId : null : null;
+            else row[fieldId] = index === 0 ? (_record_fieldId = record[fieldId]) != null ? _record_fieldId : null : null;
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+/** How many rows {@link productExportRows} writes for a product. */ export function productExportRowCount(stored) {
+    var _ref;
+    var _stored_mediaUrls;
+    const variants = Array.isArray(stored.variants) ? stored.variants.length : 0;
+    const images = (_ref = (_stored_mediaUrls = stored.mediaUrls) == null ? void 0 : _stored_mediaUrls.length) != null ? _ref : stored.imageUrl ? 1 : 0;
+    return Math.max(1, variants, images);
+}
+const text = (value)=>value === null || value === undefined ? '' : String(value).trim();
+/** A money cell as US dollars: the derived amount, or the number as typed. */ function dollars(value) {
+    if (value === null || value === undefined || value === '') return {
+        ok: true,
+        value: null
+    };
+    if (typeof value === 'number') return {
+        ok: true,
+        value
+    };
+    if (typeof value === 'object' && 'amountMinor' in value) {
+        const amount = value;
+        if (String(amount.currency).toUpperCase() !== 'USD') {
+            return {
+                ok: false,
+                message: `Prices are in US dollars; ${amount.currency} is not converted.`
+            };
+        }
+        return {
+            ok: true,
+            value: Math.round(Number(amount.amountMinor)) / 100
+        };
+    }
+    const number = Number(value);
+    return Number.isFinite(number) ? {
+        ok: true,
+        value: number
+    } : {
+        ok: false,
+        message: `"${String(value)}" is not a price.`
+    };
+}
+/** The tags a cell names, in their own case. */ export function productTagList(value) {
+    const list = Array.isArray(value) ? value : String(value != null ? value : '').split(',');
+    const seen = new Set();
+    const out = [];
+    for (const raw of list){
+        const tag = String(raw).trim();
+        if (!tag || seen.has(tag)) continue;
+        seen.add(tag);
+        out.push(tag);
+    }
+    return out;
+}
+/**
+ * A row's values the way the plan compares them with a record: prices in
+ * dollars, a fixed list's label checked, tags as one comma list, Published
+ * read as the status. What cannot be read is dropped as a located problem.
+ */ function normalizeRow(row) {
+    var _row_problems;
+    const values = _extends({}, row.values);
+    const problems = [
+        ...(_row_problems = row.problems) != null ? _row_problems : []
+    ];
+    const drop = (fieldId, code, message)=>{
+        problems.push({
+            fieldId,
+            raw: text(values[fieldId]),
+            code,
+            message
+        });
+        delete values[fieldId];
+    };
+    for (const fieldId of [
+        F.price,
+        F.compareAtPrice
+    ]){
+        if (!(fieldId in values)) continue;
+        const read = dollars(values[fieldId]);
+        if ('message' in read) drop(fieldId, 'invalidCurrency', read.message);
+        else values[fieldId] = read.value;
+    }
+    for (const [fieldId, picklistId] of [
+        [
+            F.kind,
+            PRODUCT_KIND_PICKLIST
+        ],
+        [
+            F.status,
+            PRODUCT_STATUS_PICKLIST
+        ],
+        [
+            F.oversellPolicy,
+            PRODUCT_OVERSELL_PICKLIST
+        ]
+    ]){
+        var _PRODUCT_FIXED_PICKLISTS_picklistId;
+        if (isBlankTransferValue(values[fieldId])) continue;
+        const id = fixedListId(picklistId, values[fieldId]);
+        if (id) values[fieldId] = fixedListLabel(picklistId, id);
+        else drop(fieldId, 'invalidJson', `"${text(values[fieldId])}" is not one of ${(_PRODUCT_FIXED_PICKLISTS_picklistId = PRODUCT_FIXED_PICKLISTS[picklistId]) == null ? void 0 : _PRODUCT_FIXED_PICKLISTS_picklistId.standardValues.map((entry)=>entry.label).join(', ')}.`);
+    }
+    if (F.tags in values && !isBlankTransferValue(values[F.tags])) {
+        values[F.tags] = productTagList(values[F.tags]).join(', ');
+    }
+    if (F.handle in values && !isBlankTransferValue(values[F.handle])) {
+        const slug = commerceSlug(text(values[F.handle]));
+        if (slug) values[F.handle] = slug;
+        else drop(F.handle, 'invalidUrl', `"${text(values[F.handle])}" has no letters or numbers to make a handle from.`);
+    }
+    if (F.published in values) {
+        if (isBlankTransferValue(values[F.status]) && typeof values[F.published] === 'boolean') {
+            values[F.status] = values[F.published] ? STATUS_LABELS.active : STATUS_LABELS.draft;
+        }
+        delete values[F.published];
+    }
+    return _extends({}, row, {
+        values
+    }, problems.length ? {
+        problems
+    } : {});
+}
+const pick = (values, fieldIds)=>{
+    const out = {};
+    for (const fieldId of fieldIds)if (fieldId in values) out[fieldId] = values[fieldId];
+    return out;
+};
+const hasAny = (values, fieldIds)=>fieldIds.some((fieldId)=>!isBlankTransferValue(values[fieldId]));
+/** Which product a row belongs to in the file. */ function groupKey(row, position) {
+    const handle = text(row.values[F.handle]);
+    if (handle) return `h:${handle}`;
+    const id = text(row.values['id']);
+    if (id) return `i:${id}`;
+    return `r:${position}`;
+}
+/** Warnings, tallied the way the core tallies them, for what this plan adds and merges. */ let Tally = class Tally {
+    merge(warnings) {
+        for (const warning of warnings){
+            var _entry;
+            const entry = this.entry(warning.class, warning.requiresAcknowledgement);
+            entry.count += warning.count;
+            for (const sample of warning.samples){
+                entry.rowSet.add(sample.row);
+                if (entry.samples.length < 5) entry.samples.push(sample);
+            }
+            for (const fieldId of warning.fieldIds)entry.fieldSet.add(fieldId);
+            (_entry = entry).requiresAcknowledgement || (_entry.requiresAcknowledgement = warning.requiresAcknowledgement);
+        }
+    }
+    add(warningClass, sample) {
+        const entry = this.entry(warningClass, true);
+        entry.count += 1;
+        entry.rowSet.add(sample.row);
+        if (sample.fieldId) entry.fieldSet.add(sample.fieldId);
+        if (entry.samples.length < 5) entry.samples.push(sample);
+    }
+    entry(warningClass, acknowledge) {
+        let entry = this.byClass.get(warningClass);
+        if (!entry) {
+            entry = {
+                class: warningClass,
+                count: 0,
+                rows: 0,
+                fieldIds: [],
+                samples: [],
+                requiresAcknowledgement: acknowledge,
+                rowSet: new Set(),
+                fieldSet: new Set()
+            };
+            this.byClass.set(warningClass, entry);
+        }
+        return entry;
+    }
+    list(order) {
+        return [
+            ...this.byClass.values()
+        ].sort((a, b)=>order.indexOf(a.class) - order.indexOf(b.class)).map((_0)=>{
+            let { rowSet, fieldSet } = _0, warning = _object_without_properties_loose(_0, [
+                "rowSet",
+                "fieldSet"
+            ]);
+            return _extends({}, warning, {
+                rows: Math.max(rowSet.size, warning.rows),
+                fieldIds: [
+                    ...fieldSet
+                ]
+            });
+        });
+    }
+    constructor(){
+        this.byClass = new Map();
+    }
+};
+/** The order the core lists warning classes in. */ const WARNING_ORDER = TRANSFER_WARNING_CLASSES;
+/** A variant line's identity in the product it targets. */ function optionKey(values, names) {
+    const parts = [];
+    OPTION_VALUE_FIELDS.forEach((fieldId, axis)=>{
+        const value = text(values[fieldId]);
+        if (value && names[axis]) parts.push(`${names[axis]}=${value.toLowerCase()}`);
+    });
+    return parts.length ? parts.join('|') : null;
+}
+/** The value a field's diff leaves, or what the record held. */ function after(diff, before, fieldId) {
+    const change = diff.find((entry)=>entry.fieldId === fieldId);
+    return change ? change.after : before[fieldId];
+}
+/**
+ * A product's document from its record values (see {@link productRecord}),
+ * for checking what a plan would store with the model's own rules.
+ */ export function productFromRecord(values, variants) {
+    var _fixedListId, _fixedListId1;
+    const names = OPTION_NAME_FIELDS.map((fieldId)=>text(values[fieldId]));
+    const options = [];
+    names.forEach((name, axis)=>{
+        if (!name) return;
+        const seen = [];
+        for (const variant of variants){
+            const value = text(variant.values[OPTION_VALUE_FIELDS[axis]]);
+            if (value && !seen.includes(value)) seen.push(value);
+        }
+        options.push({
+            name,
+            values: seen
+        });
+    });
+    return _extends({
+        name: text(values[F.title]),
+        slug: text(values[F.handle]),
+        type: (_fixedListId = fixedListId(PRODUCT_KIND_PICKLIST, values[F.kind])) != null ? _fixedListId : 'physical',
+        status: (_fixedListId1 = fixedListId(PRODUCT_STATUS_PICKLIST, values[F.status])) != null ? _fixedListId1 : 'active'
+    }, options.length ? {
+        options
+    } : {}, {
+        variants: variants.map((variant)=>variantFromRecord(variant.id, variant.values, names))
+    });
+}
+/** One variant of a document from its record values. */ export function variantFromRecord(id, values, optionNames) {
+    const options = {};
+    OPTION_VALUE_FIELDS.forEach((fieldId, axis)=>{
+        const name = text(optionNames[axis]);
+        const value = text(values[fieldId]);
+        if (name && value) options[name] = value;
+    });
+    const number = (fieldId)=>{
+        const raw = values[fieldId];
+        return raw === null || raw === undefined || raw === '' || !Number.isFinite(Number(raw)) ? undefined : Number(raw);
+    };
+    const inventory = number(F.inventory);
+    return _extends({
+        id
+    }, Object.keys(options).length ? {
+        options
+    } : {}, {
+        priceUsd: number(F.price)
+    }, text(values[F.sku]) ? {
+        sku: text(values[F.sku])
+    } : {}, text(values[F.barcode]) ? {
+        barcode: text(values[F.barcode])
+    } : {}, number(F.compareAtPrice) !== undefined ? {
+        compareAtPriceUsd: number(F.compareAtPrice)
+    } : {}, number(F.weightGrams) !== undefined ? {
+        weightGrams: number(F.weightGrams)
+    } : {}, text(values[F.variantImage]) ? {
+        imageUrl: text(values[F.variantImage])
+    } : {}, {
+        inventory: inventory === undefined ? null : Math.max(0, Math.round(inventory))
+    });
+}
+/** The fields a new product is refused without. */ const PRODUCT_PLAN_FIELDS = (fields)=>fields.filter((field)=>!VARIANT_LEVEL_FIELDS.includes(field.id)).map((field)=>field.id === F.title ? _extends({}, field, {
+            required: true
+        }) : field);
+const VARIANT_PLAN_FIELDS = (fields)=>fields.filter((field)=>VARIANT_LEVEL_FIELDS.includes(field.id)).map((field)=>field.id === F.price ? _extends({}, field, {
+            required: true
+        }) : field);
+/**
+ * The products resource's plan: the core's plan per product and per variant,
+ * folded back into one verdict per file row (see the block header).
+ */ export function planProductTransfer(input, context) {
+    const rows = input.rows.map(normalizeRow);
+    const tally = new Tally();
+    // The groups, in the order their first rows appear.
+    const groups = new Map();
+    rows.forEach((row, position)=>{
+        var _groups_get;
+        const key = groupKey(row, position);
+        const group = (_groups_get = groups.get(key)) != null ? _groups_get : {
+            key,
+            positions: []
+        };
+        group.positions.push(position);
+        groups.set(key, group);
+    });
+    const ordered = [
+        ...groups.values()
+    ];
+    // The product half: each group's first row, with the group's images and option names.
+    const leaders = ordered.map((group)=>{
+        const first = rows[group.positions[0]];
+        const values = pick(first.values, [
+            ...PRODUCT_LEVEL_FIELDS,
+            'id'
+        ]);
+        const images = [];
+        for (const position of group.positions){
+            var _rows_position;
+            const url = text((_rows_position = rows[position]) == null ? void 0 : _rows_position.values[F.image]);
+            if (url && !images.includes(url)) images.push(url);
+        }
+        if (images.length) values[F.image] = images;
+        else delete values[F.image];
+        OPTION_NAME_FIELDS.forEach((fieldId)=>{
+            if (!isBlankTransferValue(values[fieldId])) return;
+            for (const position of group.positions){
+                var _rows_position;
+                const name = text((_rows_position = rows[position]) == null ? void 0 : _rows_position.values[fieldId]);
+                if (name) {
+                    values[fieldId] = name;
+                    break;
+                }
+            }
+        });
+        return _extends({}, first, {
+            values
+        });
+    });
+    const leaderMatches = ordered.map((group)=>{
+        var _input_matches_group_positions_;
+        return (_input_matches_group_positions_ = input.matches[group.positions[0]]) != null ? _input_matches_group_positions_ : {
+            kind: 'new'
+        };
+    });
+    const productPlan = buildTransferPlan({
+        fields: PRODUCT_PLAN_FIELDS(input.fields),
+        rows: leaders,
+        matches: leaderMatches,
+        existing: input.existing,
+        policy: input.policy,
+        limits: context.maxCreates === undefined ? {} : {
+            maxCreates: context.maxCreates
+        }
+    });
+    tally.merge(productPlan.warnings);
+    const variantFields = VARIANT_PLAN_FIELDS(input.fields);
+    const out = new Array(rows.length);
+    // Slugs this plan gives new products, so two new ones never share one.
+    const handedOut = new Set();
+    ordered.forEach((group, at)=>{
+        var _input_existing_get, _before_PRODUCT_VARIANT_ORDER;
+        const planned = productPlan.rows[at];
+        const leaderPosition = group.positions[0];
+        const leaderIndex = rows[leaderPosition].index;
+        const original = (position)=>{
+            var _input_matches_position;
+            return (_input_matches_position = input.matches[position]) != null ? _input_matches_position : {
+                kind: 'new'
+            };
+        };
+        // A product that writes nothing: every row of it follows its first.
+        if (planned.verdict === 'skip' || planned.verdict === 'fail') {
+            for (const position of group.positions){
+                const row = rows[position];
+                out[position] = position === leaderPosition ? planned : _extends({
+                    index: row.index,
+                    verdict: planned.verdict,
+                    recordId: null
+                }, planned.reason ? {
+                    reason: planned.reason
+                } : {}, {
+                    diff: [],
+                    heldBack: [],
+                    warnings: [],
+                    match: original(position)
+                });
+            }
+            return;
+        }
+        const creating = planned.verdict === 'create';
+        const productId = creating ? context.newProductId() : planned.recordId;
+        const before = creating ? {} : (_input_existing_get = input.existing.get(productId)) != null ? _input_existing_get : {};
+        const optionNames = OPTION_NAME_FIELDS.map((fieldId)=>text(after(planned.diff, before, fieldId)) || null);
+        // The variants the product has, and which one each line names.
+        const existingVariants = creating ? [] : ((_before_PRODUCT_VARIANT_ORDER = before[PRODUCT_VARIANT_ORDER]) != null ? _before_PRODUCT_VARIANT_ORDER : []).map((id)=>{
+            var _before_productVariantKey;
+            return {
+                id,
+                values: (_before_productVariantKey = before[productVariantKey(id)]) != null ? _before_productVariantKey : {}
+            };
+        });
+        const lines = group.positions.filter((position)=>{
+            const values = rows[position].values;
+            return hasAny(values, VARIANT_LEVEL_FIELDS);
+        });
+        const claimed = new Map();
+        const lineTargets = new Map();
+        const lineMatches = [];
+        const lineRows = [];
+        const linePositions = [];
+        const existingVariantValues = new Map();
+        const duplicates = new Map();
+        for (const position of lines){
+            const row = rows[position];
+            const sku = text(row.values[F.sku]).toLowerCase();
+            const key = optionKey(row.values, optionNames);
+            let target = sku ? existingVariants.find((variant)=>text(variant.values[F.sku]).toLowerCase() === sku) : undefined;
+            let via = sku ? {
+                fieldId: F.sku,
+                value: sku
+            } : undefined;
+            if (!target && key) {
+                target = existingVariants.find((variant)=>optionKey(variant.values, optionNames) === key);
+                via = {
+                    fieldId: F.option1Value,
+                    value: key
+                };
+            }
+            if (!target && !key && !sku && existingVariants.length === 1 && lines.length === 1) {
+                var _ref;
+                target = existingVariants[0];
+                via = {
+                    fieldId: 'id',
+                    value: (_ref = target == null ? void 0 : target.id) != null ? _ref : ''
+                };
+            }
+            // Two lines naming one variant, or one new variant twice: the first one counts.
+            const identity = target ? `v:${target.id}` : sku ? `s:${sku}` : key ? `o:${key}` : null;
+            const earlier = identity ? claimed.get(identity) : undefined;
+            if (earlier !== undefined) {
+                duplicates.set(position, earlier);
+                continue;
+            }
+            if (identity) claimed.set(identity, position);
+            const id = target ? target.id : context.newVariantId();
+            lineTargets.set(position, _extends({
+                id,
+                isNew: !target
+            }, via ? {
+                via
+            } : {}));
+            lineRows.push(_extends({}, row, {
+                values: pick(row.values, VARIANT_LEVEL_FIELDS)
+            }));
+            linePositions.push(position);
+            if (target) {
+                existingVariantValues.set(`${productId}::${target.id}`, target.values);
+                lineMatches.push({
+                    kind: 'matched',
+                    recordId: `${productId}::${target.id}`,
+                    via: via
+                });
+            } else {
+                lineMatches.push({
+                    kind: 'new'
+                });
+            }
+        }
+        const variantPlan = buildTransferPlan({
+            fields: variantFields,
+            rows: lineRows,
+            matches: lineMatches,
+            existing: existingVariantValues,
+            policy: input.policy
+        });
+        tally.merge(variantPlan.warnings);
+        const lineVerdicts = new Map();
+        lineRows.forEach((row, at)=>{
+            const position = linePositions[at];
+            const verdict = variantPlan.rows[at];
+            const target = lineTargets.get(position);
+            // Stock kept per location moves per location, never as one total.
+            if (target && !target.isNew && verdict.verdict === 'update') {
+                const values = existingVariantValues.get(`${productId}::${target.id}`);
+                if ((values == null ? void 0 : values.$byLocation) && verdict.diff.some((change)=>change.fieldId === F.inventory)) {
+                    verdict.diff = verdict.diff.filter((change)=>change.fieldId !== F.inventory);
+                    verdict.heldBack = [
+                        ...verdict.heldBack,
+                        F.inventory
+                    ];
+                    verdict.warnings = [
+                        ...new Set([
+                            ...verdict.warnings,
+                            'lockedRule'
+                        ])
+                    ];
+                    tally.add('lockedRule', {
+                        row: row.index,
+                        fieldId: F.inventory,
+                        value: text(row.values[F.inventory]),
+                        detail: 'This variant’s stock is kept by location; change it per location on the products page.'
+                    });
+                    if (!verdict.diff.length) verdict.verdict = 'unchanged';
+                }
+            }
+            lineVerdicts.set(position, verdict);
+        });
+        // A new product needs a variant.
+        const createdLines = [
+            ...lineVerdicts.entries()
+        ].filter(([, verdict])=>verdict.verdict === 'create');
+        if (creating && !createdLines.length) {
+            for (const position of group.positions){
+                const row = rows[position];
+                out[position] = {
+                    index: row.index,
+                    verdict: 'fail',
+                    recordId: null,
+                    reason: 'missingRequired',
+                    missing: [
+                        F.price
+                    ],
+                    diff: position === leaderPosition ? planned.diff : [],
+                    heldBack: [],
+                    warnings: position === leaderPosition ? planned.warnings : [],
+                    match: original(position)
+                };
+            }
+            return;
+        }
+        // The handle a new product is stored under: the file's, or one made from its title.
+        let slug = '';
+        let problem;
+        if (creating) {
+            const base = text(after(planned.diff, before, F.handle)) || commerceSlug(text(after(planned.diff, before, F.title))) || 'product';
+            const taken = (candidate)=>handedOut.has(candidate) || Boolean(context.slugTaken == null ? void 0 : context.slugTaken.call(context, candidate));
+            slug = base;
+            for(let suffix = 2; taken(slug); suffix += 1){
+                const tail = `-${suffix}`;
+                slug = `${base.slice(0, COMMERCE_SLUG_MAX_LENGTH - tail.length)}${tail}`;
+            }
+            handedOut.add(slug);
+            if (slug !== base) {
+                tally.add('lockedRule', {
+                    row: leaderIndex,
+                    fieldId: F.handle,
+                    value: base,
+                    detail: `Another product holds /products/${base}; this one is created at /products/${slug}.`
+                });
+                planned.warnings = [
+                    ...new Set([
+                        ...planned.warnings,
+                        'lockedRule'
+                    ])
+                ];
+                planned.heldBack = [
+                    ...planned.heldBack,
+                    F.handle
+                ];
+            }
+        }
+        // What the product would hold once every row of it is written, by the model's own rules.
+        const productValues = _extends({}, before);
+        for (const change of planned.diff)productValues[change.fieldId] = change.after;
+        if (creating) productValues[F.handle] = slug;
+        const finalVariants = existingVariants.map((variant)=>({
+                id: variant.id,
+                values: _extends({}, variant.values)
+            }));
+        for (const [position, verdict] of lineVerdicts){
+            if (verdict.verdict !== 'create' && verdict.verdict !== 'update') continue;
+            const target = lineTargets.get(position);
+            let entry = finalVariants.find((variant)=>variant.id === target.id);
+            if (!entry) {
+                entry = {
+                    id: target.id,
+                    values: {}
+                };
+                finalVariants.push(entry);
+            }
+            for (const change of verdict.diff)entry.values[change.fieldId] = change.after;
+        }
+        if (finalVariants.length > COMMERCE_MAX_VARIANTS) {
+            problem = `A product holds at most ${COMMERCE_MAX_VARIANTS} variants; this file gives it ${finalVariants.length}.`;
+        } else {
+            const check = validateProduct(productFromRecord(productValues, finalVariants));
+            if (check) problem = check;
+        }
+        const create = creating ? {
+            slug,
+            values: Object.fromEntries(planned.diff.map((change)=>[
+                    change.fieldId,
+                    change.after
+                ])),
+            variants: createdLines.map(([position, verdict])=>({
+                    id: lineTargets.get(position).id,
+                    values: Object.fromEntries(verdict.diff.map((change)=>[
+                            change.fieldId,
+                            change.after
+                        ]))
+                }))
+        } : undefined;
+        for (const position of group.positions){
+            var _ref1, _ref2;
+            const row = rows[position];
+            const isLeader = position === leaderPosition;
+            const line = lineVerdicts.get(position);
+            const target = lineTargets.get(position);
+            const duplicateOf = duplicates.get(position);
+            const base = {
+                index: row.index,
+                match: original(position)
+            };
+            if (duplicateOf !== undefined) {
+                const firstRow = rows[duplicateOf].index;
+                tally.add('duplicateInFile', {
+                    row: row.index,
+                    fieldId: F.sku,
+                    value: text(row.values[F.sku]) || text(row.values[F.option1Value]),
+                    detail: `The same variant as row ${firstRow + 1}`
+                });
+                out[position] = _extends({}, base, {
+                    verdict: 'skip',
+                    recordId: creating ? null : productId,
+                    reason: 'duplicateInFile',
+                    diff: [],
+                    heldBack: [],
+                    warnings: [
+                        'duplicateInFile'
+                    ]
+                });
+                continue;
+            }
+            const productDiff = isLeader ? planned.diff : [];
+            const lineDiff = line && (line.verdict === 'create' || line.verdict === 'update') ? line.diff : [];
+            const writes = productDiff.length + lineDiff.length > 0;
+            const lineFailed = line && (line.verdict === 'fail' || line.verdict === 'skip');
+            if (lineFailed && isLeader && (productDiff.length || creating)) {
+                var _line_reason;
+                var _line_missing;
+                // The product's own changes still land; the variant on this row does not, and says so.
+                tally.add('droppedCell', _extends({
+                    row: row.index
+                }, ((_line_missing = line.missing) == null ? void 0 : _line_missing[0]) ? {
+                    fieldId: line.missing[0]
+                } : {}, {
+                    detail: `The variant on this row is not written (${(_line_reason = line.reason) != null ? _line_reason : line.verdict}).`
+                }));
+            }
+            const warnings = [
+                ...new Set([
+                    ...isLeader ? planned.warnings : [],
+                    ...(_ref1 = line == null ? void 0 : line.warnings) != null ? _ref1 : []
+                ])
+            ];
+            const heldBack = [
+                ...isLeader ? planned.heldBack : [],
+                ...(_ref2 = line == null ? void 0 : line.heldBack) != null ? _ref2 : []
+            ];
+            const plan = _extends({
+                productId,
+                leader: leaderIndex,
+                role: creating ? isLeader ? 'create' : 'part' : 'update'
+            }, target && lineDiff.length ? {
+                variant: {
+                    id: target.id,
+                    isNew: target.isNew
+                }
+            } : {}, isLeader && create ? {
+                create
+            } : {}, problem ? {
+                problem
+            } : {});
+            if (lineFailed && (!isLeader || !(productDiff.length || creating))) {
+                out[position] = _extends({}, base, {
+                    verdict: line.verdict,
+                    recordId: creating ? null : productId
+                }, line.reason ? {
+                    reason: line.reason
+                } : {}, line.missing ? {
+                    missing: line.missing
+                } : {}, {
+                    diff: [],
+                    heldBack,
+                    warnings
+                });
+                continue;
+            }
+            const verdict = creating ? isLeader || writes ? 'create' : 'unchanged' : writes ? 'update' : 'unchanged';
+            out[position] = _extends({}, base, {
+                verdict,
+                recordId: creating ? null : productId,
+                diff: [
+                    ...productDiff,
+                    ...lineDiff
+                ],
+                heldBack,
+                warnings
+            }, verdict === 'create' || verdict === 'update' ? {
+                commerce: plan
+            } : problem ? {
+                commerce: plan
+            } : {});
+        }
+    });
+    const summary = {
+        create: 0,
+        update: 0,
+        unchanged: 0,
+        skip: 0,
+        fail: 0,
+        total: out.length
+    };
+    for (const row of out)summary[row.verdict] += 1;
+    const warnings = tally.list(WARNING_ORDER);
+    return {
+        rows: out,
+        summary,
+        warnings,
+        acknowledgementsRequired: warnings.filter((entry)=>entry.requiresAcknowledgement).map((entry)=>entry.class)
+    };
+}
+/** The handles a plan may create products under, for the server to ask which are taken. */ export function productPlanHandles(rows) {
+    const out = new Set();
+    for (const row of rows){
+        const handle = commerceSlug(text(row.values[F.handle])) || commerceSlug(text(row.values[F.title]));
+        if (handle) out.add(handle);
+    }
+    return [
+        ...out
+    ];
+}
+/** The product fields a row's changes set, as the document stores them. */ function productFieldPatch(changes, categoryIdsOf) {
+    var _fixedListId, _fixedListId1;
+    const patch = {};
+    const has = (fieldId)=>fieldId in changes;
+    const value = (fieldId)=>changes[fieldId];
+    if (has(F.title)) patch.name = text(value(F.title));
+    if (has(F.description)) patch.description = text(value(F.description)) || undefined;
+    if (has(F.kind)) patch.type = (_fixedListId = fixedListId(PRODUCT_KIND_PICKLIST, value(F.kind))) != null ? _fixedListId : 'physical';
+    if (has(F.status)) patch.status = (_fixedListId1 = fixedListId(PRODUCT_STATUS_PICKLIST, value(F.status))) != null ? _fixedListId1 : 'active';
+    if (has(F.tags)) patch.tags = productTagList(value(F.tags));
+    if (has(F.categories)) {
+        const names = Array.isArray(value(F.categories)) ? value(F.categories).map(text).filter(Boolean) : [];
+        patch.categoryIds = categoryIdsOf(names);
+    }
+    if (has(F.image)) {
+        const urls = Array.isArray(value(F.image)) ? value(F.image).map(text).filter(Boolean) : [];
+        patch.mediaUrls = urls;
+    }
+    if (has(F.taxExempt)) patch.taxExempt = value(F.taxExempt) === true;
+    if (has(F.oversellPolicy)) {
+        var _fixedListId2;
+        patch.oversellPolicy = (_fixedListId2 = fixedListId(PRODUCT_OVERSELL_PICKLIST, value(F.oversellPolicy))) != null ? _fixedListId2 : 'deny';
+    }
+    if (has(F.lowStockThreshold)) {
+        const threshold = Number(value(F.lowStockThreshold));
+        patch.lowStockThreshold = value(F.lowStockThreshold) === null || !Number.isFinite(threshold) ? undefined : Math.max(0, Math.round(threshold));
+    }
+    return patch;
+}
+/** A product with one planned row's changes written into it — the product's own on its first row, and the row's variant. */ export function applyProductRow(current, changes, categoryIdsOf) {
+    var _current_options, _changes_product;
+    const next = _extends({}, current, {
+        options: ((_current_options = current.options) != null ? _current_options : []).map((option)=>_extends({}, option, {
+                values: [
+                    ...option.values
+                ]
+            })),
+        variants: current.variants.map((variant)=>_extends({}, variant))
+    });
+    const product = (_changes_product = changes.product) != null ? _changes_product : {};
+    Object.assign(next, productFieldPatch(product, categoryIdsOf));
+    if (F.seoTitle in product || F.seoDescription in product) {
+        var _current_seo;
+        const seo = _extends({}, (_current_seo = current.seo) != null ? _current_seo : {});
+        if (F.seoTitle in product) seo.title = text(product[F.seoTitle]) || undefined;
+        if (F.seoDescription in product) seo.description = text(product[F.seoDescription]) || undefined;
+        next.seo = Object.fromEntries(Object.entries(seo).filter(([, entry])=>entry !== undefined));
+    }
+    // An option the product does not have yet takes its name.
+    const options = next.options;
+    OPTION_NAME_FIELDS.forEach((fieldId, axis)=>{
+        const name = text(product[fieldId]);
+        if (name && !options[axis]) options[axis] = {
+            name,
+            values: []
+        };
+    });
+    const variant = changes.variant;
+    if (variant) {
+        const names = options.map((option)=>{
+            var _ref;
+            return (_ref = option == null ? void 0 : option.name) != null ? _ref : null;
+        });
+        const at = next.variants.findIndex((entry)=>entry.id === variant.id);
+        const existing = at >= 0 ? next.variants[at] : null;
+        const record = existing ? variantRecord(existing, options) : {};
+        const merged = variantFromRecord(variant.id, _extends({}, record, variant.values), names);
+        const written = existing ? _extends({}, existing, merged, existing.inventoryByLocation ? {
+            inventoryByLocation: existing.inventoryByLocation,
+            inventory: existing.inventory
+        } : {}) : merged;
+        for (const key of [
+            'sku',
+            'barcode',
+            'compareAtPriceUsd',
+            'weightGrams',
+            'imageUrl'
+        ]){
+            if (merged[key] === undefined) delete written[key];
+        }
+        if (at >= 0) next.variants[at] = written;
+        else next.variants.push(written);
+        // Each option value the variant holds is one its option offers.
+        options.forEach((option, axis)=>{
+            const value = text(variant.values[OPTION_VALUE_FIELDS[axis]]);
+            if (option && value && !option.values.includes(value)) option.values.push(value);
+        });
+    }
+    next.options = options.filter(Boolean);
+    if (!next.options.length) delete next.options;
+    return next;
+}
+/** A new product's document from its leader's plan, before the platform's stamps. */ export function createProductDocument(create, categoryIdsOf) {
+    const base = productFromRecord(_extends({}, create.values, {
+        [F.handle]: create.slug
+    }), create.variants);
+    return applyProductRow(_extends({}, base, {
+        variants: base.variants
+    }), {
+        product: Object.fromEntries(Object.entries(create.values).filter(([fieldId])=>!OPTION_NAME_FIELDS.includes(fieldId)))
+    }, categoryIdsOf);
+}
+/** The values one planned row changes, split into the product's and its variant's. */ export function productRowChanges(row) {
+    var _row_commerce;
+    const product = {};
+    const variant = {};
+    for (const change of row.diff){
+        if (VARIANT_LEVEL_FIELDS.includes(change.fieldId)) variant[change.fieldId] = change.after;
+        else if (PRODUCT_LEVEL_FIELDS.includes(change.fieldId)) product[change.fieldId] = change.after;
+    }
+    const target = (_row_commerce = row.commerce) == null ? void 0 : _row_commerce.variant;
+    return _extends({
+        product
+    }, target ? {
+        variant: _extends({}, target, {
+            values: variant
+        })
+    } : {});
+}
+
+//# sourceMappingURL=product-transfer.js.map