@aglyn/plugins-commerce 1.0.0-beta.143

package/src/lib/components/console/products-hub-card.component.js

@@ -0,0 +1,1280 @@
+/**
+ * @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.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import * as Aglyn from "@aglyn/aglyn";
+import * as CommerceModel from "../../model/index.js";
+import { PRODUCT_LIST_FILTER_FIELDS } from "../../constants/product-filters.js";
+import { CardDisplay, useConfirmationContext } from "@aglyn/shared-ui-jsx";
+import { ListPagination } from "@aglyn/shared-ui-jsx/components/list-pagination.component";
+import QuotaReadoutComponent from "@aglyn/shared-ui-jsx/components/quota-readout.component";
+import { TABLE_PAGE_SIZE_DEFAULT } from "@aglyn/shared-ui-jsx/const/table-pagination";
+import { ScrollTable } from "@aglyn/shared-ui-jsx/components/scroll-table.component";
+import { useSnackbar } from "@aglyn/shared-ui-snackstack";
+import { Timestamp } from "@aglyn/shared-util-timestamp";
+import { Alert, Box, Button, Chip, Dialog, DialogActions, DialogContent, DialogTitle, MenuItem, Stack, TableBody, TableCell, TableHead, TableRow, TextField, Typography } from "@mui/material";
+import { addDoc, collection, doc, documentId, getCountFromServer, limit, orderBy, query, updateDoc, where } from "firebase/firestore";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useFirestore } from "@aglyn/tenant-feature-instance";
+import { listFilterConstraints, useFirestoreCollection, writeGuardedBySeed } from "@aglyn/tenant-feature-instance";
+import { useHostResourceApi } from "@aglyn/tenant-feature-instance";
+import { useOrgPlan } from "@aglyn/tenant-feature-instance";
+import ProductEditorDialog from "./product-editor-dialog.component.js";
+import ProductsHubZone from "./products-hub-zone.component.js";
+import { pluginDocsHelp } from "@aglyn/aglyn";
+import { useConsoleWidgetSlot } from "@aglyn/aglyn/app-utils/console-widget-slot-context";
+/**
+ * How many catalog documents the table's listener holds.
+ *
+ * A CEILING, not a page size: a 25,000-product catalog does not belong in a
+ * table, and three other readers on this card — the CSV export, the importer's
+ * duplicate-slug check and the reserved-stock clock — need the window whole.
+ * The footer pages what this holds; the query is what bounds it.
+ */ const CATALOG_CEILING = 500;
+/**
+ * How many of ONE product's license keys the dialog reads.
+ *
+ * Per product, not per store: the query carries the `productId` equality, so
+ * this bounds a single pool rather than the site's whole key collection.
+ */ const KEY_POOL_CEILING = 500;
+const STATUS_COLOR = {
+    active: 'success',
+    draft: 'warning',
+    archived: 'default'
+};
+/**
+ * Products hub v1 (AGL-279): the catalog manager replacing the Commerce
+ * Starter card — search + status filter over `hosts/{hostId}/products`,
+ * full editor dialog, duplicate, archive/activate, soft delete (past
+ * order rows keep resolving). Product cap (`productsPerHost`, AGL-278)
+ * gated here on create/duplicate/import (AGL-471); server-side
+ * enforcement of the client-write path rides AGL-473.
+ */ export function ProductsHubCard(props) {
+    var _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9, _ref10, _ref11, _ref12;
+    var _importing_parsed, _importing_parsed1, _importing_parsed2;
+    const { hostId } = props;
+    const firestore = useFirestore();
+    const { enqueueSnackbar } = useSnackbar();
+    // Product cap (AGL-471): per-plan `productsPerHost`, same pattern as
+    // locations. Console-side gate; server enforcement rides AGL-473.
+    const createHostResource = useHostResourceApi();
+    const { org, ready: planReady } = useOrgPlan(hostId);
+    const { confirm } = useConfirmationContext();
+    const [search, setSearch] = useState('');
+    /*
+   * WHICH field the search box searches (AGL-2501).
+   *
+   * The box used to compare four fields at once — name, slug, tag, SKU — over
+   * the rows the listener had already fetched. Server-side that is not one
+   * query: Firestore allows a single `array-contains` per query and cannot OR
+   * across fields, so four fields at once means four queries and a merge, and
+   * a merged result cannot be paged or capped coherently.
+   *
+   * Naming the field is the honest trade. It buys a search that reaches the
+   * WHOLE catalog instead of an arbitrary five hundred rows of it, which is
+   * the case the old box got wrong — and a merchant looking for a SKU knows
+   * they are looking for a SKU.
+   */ const [searchField, setSearchField] = useState('name');
+    const [statusFilter, setStatusFilter] = useState('all');
+    const [editing, setEditing] = useState(null);
+    const [creating, setCreating] = useState(false);
+    const [adjusting, setAdjusting] = useState(null);
+    const [importing, setImporting] = useState(null);
+    const [keysFor, setKeysFor] = useState(null);
+    const [keysText, setKeysText] = useState('');
+    /**
+   * What the import zone set for the import in the dialog, and what the last
+   * import created with those options (AGL-2916), which the hub's zone hands
+   * to its widgets.
+   */ const [importOptions, setImportOptions] = useState({});
+    const [lastImport, setLastImport] = useState(null);
+    const WidgetSlot = useConsoleWidgetSlot();
+    const { data: productDocs, status: productsStatus, /**
+     * The product rows the stock dialog is seeded from are unconfirmed by
+     * the server (AGL-1358). A stock adjustment does not write the delta —
+     * it recomputes the WHOLE `variants` array from the seeded product and
+     * replaces it, so a cached seed silently reverts every sale, return and
+     * adjustment the server has recorded since that snapshot, on every
+     * variant and every location.
+     */ fromCache: productsFromCache } = useFirestoreCollection(()=>{
+        /*
+       * FILTERED BY THE QUERY, and ordered rather than merely capped
+       * (AGL-2501, AGL-2292).
+       *
+       * `limit(500)` with no `orderBy` returns documents in ID order, and
+       * products are created at `createResourceUid()` — so that was a
+       * pseudo-random SAMPLE of five hundred, which the client `.sort()` by
+       * name below dressed up as a reliable alphabetical page. The search then
+       * ran over that sample, so a product on the wrong side of the cap
+       * answered "no products match": the one answer a search must never get
+       * wrong, on the list a merchant uses to find one item in their catalog.
+       *
+       * The cap STAYS — a 25,000-product catalog does not belong in a table,
+       * and the head-count has been a server aggregate since AGL-1716. What
+       * changes is that a filter now reaches the whole collection BEFORE the
+       * cap applies.
+       *
+       * ONE request, because Firestore allows one `array-contains` and the
+       * shared translator builds one predicate. Whichever control is set alone
+       * is answered entirely by the server; with BOTH set the name reaches the
+       * whole catalog and the status narrows those matches client-side below,
+       * which is complete unless a single name matches more than five hundred
+       * products.
+       *
+       * ⚠️ The default ordering is by DOCUMENT ID, not by `nameLower`.
+       * Ordering by a denormalized key drops every document that lacks it, and
+       * an unfiltered list must not be able to hide a product — a catalog
+       * imported before the search keys existed, or written by a path that
+       * forgot them, would simply stop appearing. Under a name filter the
+       * ordering does move to `nameLower`, and there it is safe: a document
+       * without the key has no `nameTokens` either, so the `array-contains`
+       * has already excluded it.
+       */ const constraints = listFilterConstraints(PRODUCT_LIST_FILTER_FIELDS, search.trim() ? {
+            field: searchField,
+            op: 'contains',
+            value: search.trim()
+        } : statusFilter !== 'all' ? {
+            field: 'status',
+            op: 'equals',
+            value: statusFilter
+        } : null);
+        return query(collection(firestore, 'hosts', hostId, 'products'), ...constraints != null ? constraints : [
+            orderBy(documentId())
+        ], /*
+         * `CATALOG_CEILING + 1` is a PROBE (AGL-2501). One document past the
+         * ceiling turns "this catalog is larger than the table" into a fact.
+         * The probe row is dropped below and never rendered, exported or
+         * counted.
+         */ limit(CATALOG_CEILING + 1));
+    }, [
+        firestore,
+        hostId,
+        search,
+        searchField,
+        statusFilter
+    ], {
+        idField: '$id'
+    });
+    /*
+   * License key pool (AGL-308) for the open dialog's product — asked FOR that
+   * product, and ordered (AGL-2501).
+   *
+   * This read `limit(500)` over the site's whole `licenseKeys` collection with
+   * no `orderBy`, then filtered by `productId` in the browser. Firestore
+   * answers an unordered limit in DOCUMENT-ID order, so on a store past five
+   * hundred keys the window was an arbitrary five hundred taken across every
+   * product — and the "N available" line below counted what happened to be in
+   * it. A product whose keys all hashed high showed a pool of zero while the
+   * storefront went on delivering them.
+   *
+   * The equality moves into the query, so the window is this product's keys
+   * rather than the store's. `orderBy(documentId())` orders on the document
+   * NAME, which cannot be absent — every candidate FIELD here (`createdAtMs`,
+   * `assignedAtMs`, `revokedAtMs`) is either optional by design or absent on
+   * exactly the keys the counts are about. An equality plus an ordering on
+   * `__name__` is served by the automatic single-field index, so this adds no
+   * composite for anyone to deploy.
+   */ const { data: keyDocs } = useFirestoreCollection(()=>keysFor ? query(collection(firestore, 'hosts', hostId, 'licenseKeys'), where('productId', '==', keysFor.$id), orderBy(documentId()), // One past the ceiling, so a pool larger than the window is a
+        // fact rather than a guess from `length === 500`.
+        limit(KEY_POOL_CEILING + 1)) : null, [
+        firestore,
+        hostId,
+        keysFor == null ? void 0 : keysFor.$id
+    ], {
+        idField: '$id'
+    });
+    /** The key pool is larger than the window, so the counts below are partial. */ const keyPoolTruncated = ((_ref = keyDocs == null ? void 0 : keyDocs.length) != null ? _ref : 0) > KEY_POOL_CEILING;
+    // Locations (AGL-286): the stock dialog buckets deltas when they exist.
+    const { data: locationDocs } = useFirestoreCollection(()=>query(collection(firestore, 'hosts', hostId, 'locations'), limit(25)), [
+        firestore,
+        hostId
+    ], {
+        idField: '$id'
+    });
+    /** The read went past the ceiling, so the catalog is larger than the window. */ const catalogTruncated = ((_ref1 = productDocs == null ? void 0 : productDocs.length) != null ? _ref1 : 0) > CATALOG_CEILING;
+    const products = useMemo(()=>{
+        /*
+     * The SEARCH is gone from here — it is the query's job now, and running it
+     * twice would be worse than redundant. A server `contains` matches a word
+     * PREFIX ("cof" finds "Coffee"), while the old `includes` matched a raw
+     * substring, so a two-word search would have been sent to the server as
+     * its first word and then dropped again here by a whole-string compare
+     * that the matching row never satisfies: rows found, then hidden.
+     *
+     * The status narrowing stays, and only earns its keep when a name search
+     * is also active — that is the one combination the single predicate above
+     * cannot express, and here it runs over rows the server already matched by
+     * name across the whole catalog rather than over an arbitrary window.
+     *
+     * Soft-deleted products are still dropped here rather than in the query:
+     * `deletedAt` is absent on a live product, and Firestore cannot ask for
+     * documents that LACK a field.
+     */ return (productDocs != null ? productDocs : []).slice(0, CATALOG_CEILING).filter((product)=>!product.deletedAt).map((product)=>_extends({}, CommerceModel.liftLegacyProduct(product), {
+                $id: product.$id
+            })).filter((product)=>statusFilter === 'all' || product.status === statusFilter).sort((a, b)=>a.name.localeCompare(b.name));
+    }, [
+        productDocs,
+        statusFilter
+    ]);
+    /*==========================================
+   * THE TABLE PAGES, and the READ deliberately does not (AGL-2501).
+   *
+   * The card rendered every row of a five-hundred-document window in one wall
+   * with no footer under it — the shape this sweep is about. What it must not
+   * become is a server-paged query, because three other things in this file
+   * read the same window and every one of them needs it whole:
+   *
+   *  * `handleExport` writes the CSV from these rows. A ten-row page would
+   *    silently export ten products under a filename that claims the catalog.
+   *  * the CSV importer builds `existingSlugs` from them to refuse a
+   *    duplicate slug. Narrowed to a page, it would stop seeing the clash and
+   *    create the duplicate it exists to prevent.
+   *  * the reserved-stock clock arms off them.
+   *
+   * The window is also already correct: `orderBy(documentId())` unfiltered,
+   * `nameLower` under a name filter, and the filters themselves reach the
+   * whole collection through the query. So the fix here is the CONTROL, not
+   * the read — and the head-count beside it has been a server aggregate since
+   * AGL-1716.
+   *=========================================*/ const [page, setPage] = useState(0);
+    const [pageSize, setPageSize] = useState(TABLE_PAGE_SIZE_DEFAULT);
+    // A filter narrows the list under the reader's feet, and page four of the
+    // unfiltered catalog is not a position in the filtered one.
+    useEffect(()=>setPage(0), [
+        search,
+        searchField,
+        statusFilter
+    ]);
+    const visibleProducts = useMemo(()=>products.slice(page * pageSize, page * pageSize + pageSize), [
+        products,
+        page,
+        pageSize
+    ]);
+    /**
+   * A CLOCK, because a hold lapses without anybody writing anything
+   * (AGL-2356).
+   *
+   * The Firestore listener re-renders on document changes, and a reservation
+   * expiring is not one — `expiresAtMs` simply passes. Without a tick the
+   * "reserved" caption below would keep naming a hold that lapsed twenty
+   * minutes ago, which is worse than not showing it at all: the merchant would
+   * be told stock is spoken for while the storefront happily sells it.
+   *
+   * Only runs while something is actually held, so an ordinary catalog costs
+   * no timer. A NEW hold arrives as a document change, which re-renders, which
+   * re-arms this.
+   */ const [nowMs, setNowMs] = useState(()=>Date.now());
+    const anyHeld = useMemo(()=>products.some((product)=>CommerceModel.heldProductUnits(product, nowMs) > 0), [
+        products,
+        nowMs
+    ]);
+    useEffect(()=>{
+        if (!anyHeld) return undefined;
+        const timer = setInterval(()=>setNowMs(Date.now()), 60000);
+        return ()=>clearInterval(timer);
+    }, [
+        anyHeld
+    ]);
+    /**
+   * The catalog HEAD-COUNT is a server aggregate, not the length of the
+   * capped listener (AGL-1716, the AGL-1706 shape).
+   *
+   * The listener is `limit(500)` — correctly; a 25,000-product catalog does
+   * not belong in a table. What it must not do is answer "how many products
+   * does this site have", and it did: the length saturated at 500 and was
+   * handed to `checkQuota(org, 'productsPerHost', …)` and to the batch check
+   * the CSV importer runs. The bands are 2,500 / 10,000 / 25,000 above the
+   * window, so on Pro and up the check compared 500 against thousands and
+   * could never refuse — the card offered headroom and `api/hosts/resources`
+   * then refused the create, which is the AGL-1716 shape exactly.
+   *
+   * The aggregate is deliberately UNFILTERED, which also closes a second,
+   * quieter disagreement: `api/hosts/resources` enforces this quota with a
+   * plain `collection('products').count()`, and `softDeletes` there governs
+   * only the flat per-host cap on webhooks — so the server has always
+   * counted soft-deleted products toward `productsPerHost` while this card
+   * excluded them. The card now asks the enforcing route's question, in the
+   * enforcing route's terms.
+   *
+   * THE LIST KEEPS ITS CAP, and the filtered `products` view above still
+   * drives the table, the export and the slug set. A one-shot goes stale
+   * where a listener refreshed for free, so the count is re-read after any
+   * mutation that moves it.
+   *
+   * No counting RULE moves: `checkQuota` is untouched and `report-usage`
+   * meters contacts, storage and API requests — never the catalog.
+   */ const [productCountEpoch, setProductCountEpoch] = useState(0);
+    const [serverProductCount, setServerProductCount] = useState(null);
+    useEffect(()=>{
+        let active = true;
+        void getCountFromServer(collection(firestore, 'hosts', hostId, 'products')).then((snapshot)=>{
+            if (active) setServerProductCount(snapshot.data().count);
+        }).catch(()=>{
+        // Falls back to the live-row count below — a LOWER bound, and this
+        // card's prior behaviour. Deliberately not 0: `checkQuota` answers
+        // from whatever it is handed, and 0 used is a confident wrong
+        // number in the flattering direction.
+        });
+        return ()=>{
+            active = false;
+        };
+    }, [
+        firestore,
+        hostId,
+        productCountEpoch
+    ]);
+    // Cap against ALL live products, not the filtered view (AGL-471). This is
+    // the fallback now: pending or denied, it can only UNDERSTATE, never
+    // overstate, so nothing it gates fires on a count larger than the truth.
+    const loadedProductCount = useMemo(()=>(productDocs != null ? productDocs : []).filter((product)=>!product.deletedAt).length, [
+        productDocs
+    ]);
+    const productCount = serverProductCount != null ? serverProductCount : loadedProductCount;
+    // Gate only once the org doc has loaded: an unresolved org reads as the
+    // free tier's 0-product cap, which swallowed every Add/Duplicate click.
+    // The resources API (AGL-473) stays the authoritative cap on create.
+    //
+    // `planReady` rather than `org` truthiness (AGL-1064): a host with no
+    // owning org never produces one, and waiting on the value alone would
+    // hold this open forever. The old fallback allowed UNLIMITED during the
+    // window — safe only because the API re-checks; the controls now disable
+    // instead, which does not lean on that backstop.
+    // NULL means "not known yet", which a boolean cannot say — the old
+    // fallback object claimed UNLIMITED and every consumer believed it.
+    const productQuota = useMemo(()=>planReady ? Aglyn.checkQuota(org, 'productsPerHost', productCount) : null, [
+        org,
+        planReady,
+        productCount
+    ]);
+    const handleDuplicate = useCallback((product)=>async ()=>{
+            // Plan unknown — the control is disabled; this guards the race.
+            if (!productQuota) return;
+            if (!productQuota.allowed) {
+                return void enqueueSnackbar(`Your plan includes ${productQuota.limit} products — upgrade for more`, {
+                    variant: 'info',
+                    persist: false
+                });
+            }
+            const { $id: _sourceId } = product, copy = _object_without_properties_loose(product, [
+                "$id"
+            ]);
+            try {
+                // Duplicate is a create — rides the quota-enforcing API (AGL-473).
+                await createHostResource({
+                    hostId,
+                    resource: 'product',
+                    data: _extends({}, copy, {
+                        name: `${product.name} (copy)`,
+                        slug: CommerceModel.commerceSlug(`${product.slug}-copy`),
+                        status: 'draft',
+                        createdAtMs: Date.now(),
+                        updatedAtMs: Date.now()
+                    })
+                });
+                // A create moves the count and the aggregate is a one-shot — the
+                // listener refreshes the ROWS for free, the count has to be asked
+                // again or the cap drifts stale for the rest of the session.
+                setProductCountEpoch((epoch)=>epoch + 1);
+                enqueueSnackbar('Product duplicated as draft', {
+                    variant: 'success',
+                    persist: false
+                });
+            } catch (error) {
+                var _ref;
+                enqueueSnackbar((_ref = error == null ? void 0 : error.message) != null ? _ref : 'Could not duplicate product', {
+                    variant: 'warning',
+                    persist: false
+                });
+            }
+        }, [
+        hostId,
+        createHostResource,
+        enqueueSnackbar,
+        productQuota
+    ]);
+    const handleStatus = useCallback((product, status)=>async ()=>{
+            // A product with a variant nobody has priced (AGL-2916) stays off the
+            // storefront until the editor has a price for each.
+            if (status === 'active' && CommerceModel.productPriceMissing(product)) {
+                return void enqueueSnackbar(`Set a price for every variant of ${product.name} before activating it.`, {
+                    variant: 'info',
+                    persist: false
+                });
+            }
+            await updateDoc(doc(firestore, 'hosts', hostId, 'products', product.$id), {
+                status,
+                updatedAtMs: Date.now(),
+                updatedAt: Timestamp.now()
+            });
+        }, [
+        firestore,
+        hostId,
+        enqueueSnackbar
+    ]);
+    const handleDelete = useCallback((product)=>async ()=>{
+            const confirmed = await confirm({
+                title: 'Delete this product?',
+                description: `"${product.name}" stops being purchasable; blocks referencing ` + 'it show a checkout error until repointed.',
+                confirmationText: 'Delete',
+                confirmationButtonProps: {
+                    color: 'error'
+                }
+            }).then(()=>true).catch(()=>false);
+            if (!confirmed) return;
+            await updateDoc(doc(firestore, 'hosts', hostId, 'products', product.$id), {
+                deletedAt: Timestamp.now()
+            });
+            enqueueSnackbar('Product deleted', {
+                variant: 'success',
+                persist: false
+            });
+        }, [
+        confirm,
+        firestore,
+        hostId,
+        enqueueSnackbar
+    ]);
+    // CSV import/export (AGL-282): Shopify-dialect columns, dry-run first.
+    const handleExport = useCallback(()=>{
+        const csv = CommerceModel.productsToCsv(products);
+        const blob = new Blob([
+            csv
+        ], {
+            type: 'text/csv'
+        });
+        const anchor = document.createElement('a');
+        anchor.href = URL.createObjectURL(blob);
+        anchor.download = `products-${hostId}.csv`;
+        anchor.click();
+        URL.revokeObjectURL(anchor.href);
+    }, [
+        products,
+        hostId
+    ]);
+    const handleImportApply = useCallback(async ()=>{
+        const parsed = importing == null ? void 0 : importing.parsed;
+        if (!parsed || parsed.products.length === 0) return;
+        // Batch-aware cap (AGL-471): the whole import must fit the plan.
+        // Not startable until the plan is known (AGL-1064) — the old `org ?`
+        // guard let an import begin against an unknown cap and leaned on the
+        // API rejecting it partway through, leaving a half-imported catalog.
+        if (!planReady) return;
+        const batchQuota = Aglyn.checkQuota(org, 'productsPerHost', productCount + parsed.products.length - 1);
+        if (!batchQuota.allowed) {
+            return void enqueueSnackbar(`This import needs ${parsed.products.length} product slots — your ` + `plan allows ${batchQuota.limit}. See Billing to upgrade.`, {
+                variant: 'info',
+                persist: false
+            });
+        }
+        const existingSlugs = new Set(products.map((product)=>product.slug));
+        const created = [];
+        try {
+            // Each create rides the quota-enforcing API (AGL-473); the batch cap
+            // above short-circuits before we start, so this loop stays bounded.
+            for (const product of parsed.products){
+                var _ref, _ref1;
+                var _product_variants_, _product_mediaUrls;
+                let slug = product.slug;
+                while(existingSlugs.has(slug))slug = `${product.slug}-${Date.now() % 1000}`;
+                existingSlugs.add(slug);
+                const { id } = await createHostResource({
+                    hostId,
+                    resource: 'product',
+                    data: _extends({}, product, CommerceModel.productSearchFields(product), {
+                        slug,
+                        priceUsd: (_ref = (_product_variants_ = product.variants[0]) == null ? void 0 : _product_variants_.priceUsd) != null ? _ref : 0,
+                        inventory: CommerceModel.productInventory(product),
+                        imageUrl: (_ref1 = (_product_mediaUrls = product.mediaUrls) == null ? void 0 : _product_mediaUrls[0]) != null ? _ref1 : null,
+                        createdAtMs: Date.now(),
+                        updatedAtMs: Date.now()
+                    })
+                });
+                created.push(id);
+            }
+        } catch (error) {
+            var _ref2;
+            return void enqueueSnackbar((_ref2 = error == null ? void 0 : error.message) != null ? _ref2 : 'Import failed', {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        setLastImport({
+            key: `${Date.now().toString(36)}-${created.length}`,
+            productIds: created,
+            options: importOptions
+        });
+        setImportOptions({});
+        setImporting(null);
+        setProductCountEpoch((epoch)=>epoch + 1);
+        enqueueSnackbar(`Imported ${parsed.products.length} products`, {
+            variant: 'success',
+            persist: false
+        });
+    }, [
+        importing,
+        products,
+        hostId,
+        createHostResource,
+        enqueueSnackbar,
+        org,
+        planReady,
+        productCount,
+        importOptions
+    ]);
+    const handleAdjustSave = useCallback(async ()=>{
+        if (!adjusting) return;
+        const delta = Math.round(Number(adjusting.delta));
+        if (!delta) return;
+        const variants = CommerceModel.adjustVariantInventory(adjusting.product, adjusting.variantId, delta, adjusting.locationId || undefined);
+        /**
+     * Refuse the adjustment when the seed is unconfirmed (AGL-1358).
+     *
+     * `adjustVariantInventory` reads counts off the seeded product and
+     * returns a whole new `variants` array, which is then written over the
+     * stored one — so this is a full replace of live stock, not a delta, and
+     * `merge` could not help. The refusal also has to cover the ADJUSTMENT
+     * LOG, which is why the guard wraps both writes: a logged adjustment
+     * whose stock write never happened is worse than neither, because the
+     * history then disagrees with the count it is supposed to explain.
+     */ const verdict = await writeGuardedBySeed({
+            subject: 'stock',
+            unreadable: productsStatus === 'error',
+            fromCache: productsFromCache
+        }, async ()=>{
+            await updateDoc(doc(firestore, 'hosts', hostId, 'products', adjusting.product.$id), {
+                variants,
+                inventory: CommerceModel.productInventory({
+                    variants
+                }),
+                updatedAtMs: Date.now()
+            });
+            // Adjustment history (AGL-281): the same log the sale webhook writes.
+            await addDoc(collection(firestore, 'hosts', hostId, 'inventoryAdjustments'), _extends({
+                productId: adjusting.product.$id,
+                variantId: adjusting.variantId,
+                delta,
+                reason: adjusting.reason
+            }, adjusting.locationId ? {
+                locationId: adjusting.locationId
+            } : {}, {
+                atMs: Date.now()
+            }));
+        });
+        // Keep the dialog open with the typed delta rather than failing silently.
+        if (!verdict.ok) {
+            return void enqueueSnackbar(verdict.message, {
+                variant: 'warning',
+                persist: false
+            });
+        }
+        setAdjusting(null);
+        enqueueSnackbar('Stock adjusted', {
+            variant: 'success',
+            persist: false
+        });
+    }, [
+        adjusting,
+        firestore,
+        hostId,
+        enqueueSnackbar,
+        productsFromCache,
+        productsStatus
+    ]);
+    /** The hub's allowance check for a batch of `count` new products, for its zone. */ const roomFor = useCallback((count)=>planReady ? Aglyn.checkQuota(org, 'productsPerHost', productCount + count - 1) : null, [
+        org,
+        planReady,
+        productCount
+    ]);
+    const onCatalogCreated = useCallback(()=>setProductCountEpoch((epoch)=>epoch + 1), []);
+    const setImportOption = useCallback((key, on)=>setImportOptions((current)=>_extends({}, current, {
+                [key]: on
+            })), []);
+    const formatPrice = (product)=>{
+        const [min, max] = CommerceModel.productPriceRange(product);
+        return min === max ? `$${min}` : `$${min}–$${max}`;
+    };
+    const formatStock = (product)=>{
+        const total = CommerceModel.productInventory(product);
+        if (total == null) return '—';
+        return total > 0 ? String(total) : 'Sold out';
+    };
+    /**
+   * RESERVED UNITS, NAMED (AGL-2356).
+   *
+   * Checkout now takes a hold on the units a live session is about to buy, and
+   * that hold deliberately does NOT move `inventory` — the shelf count means
+   * units on the shelf, and half the product reads it that way. The
+   * consequence a merchant meets is that the storefront can refuse a sale of
+   * the third unit while this column says `3`, and without this caption the
+   * number is right and the behaviour looks broken.
+   *
+   * The house style of `stock-movements-card.component.tsx`: a trailing
+   * `caption` in `text.secondary`, rendered ONLY when there is something to
+   * say. Nothing is held on the overwhelming majority of products, so the
+   * column reads exactly as it does today.
+   */ const formatHeld = (product)=>{
+        const held = CommerceModel.heldProductUnits(product, nowMs);
+        return held > 0 ? ` (${held} reserved)` : '';
+    };
+    return /*#__PURE__*/ _jsxs(CardDisplay, {
+        /*
+       * The header count is the SITE'S catalog, not the rows in hand.
+       *
+       * It was `products.length`, which is the filtered, ceilinged, now-paged
+       * view — so it read 500 on a 25,000-product catalog and would read 10
+       * once the table paged. `productCount` is the same server aggregate the
+       * quota gate uses. Under a filter there is no honest number to put here:
+       * the aggregate counts the whole catalog and the view counts matches, so
+       * neither describes what the reader is looking at, and the footer's own
+       * count line answers it instead.
+       */ header: search || statusFilter !== 'all' ? 'Products' : `Products${productCount ? ` (${productCount})` : ''}`,
+        help: pluginDocsHelp('commerce', {
+            anchor: '#products-hub'
+        }),
+        contentGutterX: true,
+        contentGutterY: true,
+        children: [
+            /*#__PURE__*/ _jsxs(Stack, {
+                spacing: 2,
+                children: [
+                    /*#__PURE__*/ _jsxs(Stack, {
+                        direction: {
+                            xs: 'column',
+                            sm: 'row'
+                        },
+                        spacing: 1,
+                        children: [
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Search",
+                                placeholder: searchField === 'name' ? 'Product name' : searchField === 'skus' ? 'Whole SKU' : 'Whole barcode',
+                                value: search,
+                                onChange: (event)=>setSearch(event.target.value),
+                                size: "small",
+                                sx: {
+                                    flex: 1
+                                }
+                            }),
+                            /*#__PURE__*/ _jsxs(TextField, {
+                                label: "In",
+                                value: searchField,
+                                onChange: (event)=>setSearchField(event.target.value),
+                                size: "small",
+                                select: true,
+                                sx: {
+                                    minWidth: 110
+                                },
+                                children: [
+                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: "name",
+                                        children: 'Name'
+                                    }),
+                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: "skus",
+                                        children: 'SKU'
+                                    }),
+                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: "barcodes",
+                                        children: 'Barcode'
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsxs(TextField, {
+                                label: "Status",
+                                value: statusFilter,
+                                onChange: (event)=>setStatusFilter(event.target.value),
+                                size: "small",
+                                select: true,
+                                sx: {
+                                    minWidth: 130
+                                },
+                                children: [
+                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: "all",
+                                        children: 'All'
+                                    }),
+                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: "active",
+                                        children: 'Active'
+                                    }),
+                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: "draft",
+                                        children: 'Draft'
+                                    }),
+                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: "archived",
+                                        children: 'Archived'
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                size: "small",
+                                disabled: !productQuota,
+                                onClick: ()=>{
+                                    if (!productQuota) return;
+                                    if (!productQuota.allowed) {
+                                        return void enqueueSnackbar(`Your plan includes ${productQuota.limit} products — ` + 'upgrade for more', {
+                                            variant: 'info',
+                                            persist: false
+                                        });
+                                    }
+                                    setCreating(true);
+                                },
+                                children: 'Add product'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                disabled: !planReady,
+                                onClick: ()=>{
+                                    setImportOptions({});
+                                    setImporting({
+                                        text: '',
+                                        parsed: null
+                                    });
+                                },
+                                children: 'Import'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                disabled: products.length === 0,
+                                onClick: handleExport,
+                                children: 'Export'
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(QuotaReadoutComponent, {
+                        ready: productQuota !== null,
+                        used: productCount,
+                        limit: (_ref2 = productQuota == null ? void 0 : productQuota.limit) != null ? _ref2 : 0,
+                        noun: "product"
+                    }),
+                    /*#__PURE__*/ _jsx(ProductsHubZone, {
+                        hostId: hostId,
+                        products: products,
+                        roomFor: roomFor,
+                        lastImport: lastImport,
+                        onCreated: onCatalogCreated
+                    }),
+                    products.length === 0 ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: search || statusFilter !== 'all' ? 'No products match the current filters.' : 'Build your catalog: add a product, then drop commerce ' + 'blocks on any screen in the besigner.'
+                    }) : /*#__PURE__*/ _jsx(Box, {
+                        children: /*#__PURE__*/ _jsxs(ScrollTable, {
+                            size: "small",
+                            children: [
+                                /*#__PURE__*/ _jsx(TableHead, {
+                                    children: /*#__PURE__*/ _jsxs(TableRow, {
+                                        children: [
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                children: 'Product'
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                children: 'Status'
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                children: 'Type'
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                children: 'Price'
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                children: 'Stock'
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                children: 'Variants'
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                align: "right",
+                                                children: 'Actions'
+                                            })
+                                        ]
+                                    })
+                                }),
+                                /*#__PURE__*/ _jsx(TableBody, {
+                                    children: visibleProducts.map((product)=>{
+                                        var _STATUS_COLOR_product_status;
+                                        return /*#__PURE__*/ _jsxs(TableRow, {
+                                            hover: true,
+                                            children: [
+                                                /*#__PURE__*/ _jsxs(TableCell, {
+                                                    sx: {
+                                                        maxWidth: 260
+                                                    },
+                                                    children: [
+                                                        /*#__PURE__*/ _jsx(Typography, {
+                                                            variant: "body2",
+                                                            noWrap: true,
+                                                            children: product.name
+                                                        }),
+                                                        /*#__PURE__*/ _jsx(Typography, {
+                                                            variant: "caption",
+                                                            color: "text.secondary",
+                                                            noWrap: true,
+                                                            sx: {
+                                                                display: 'block'
+                                                            },
+                                                            children: `/${product.slug} · id: ${product.$id}`
+                                                        })
+                                                    ]
+                                                }),
+                                                /*#__PURE__*/ _jsx(TableCell, {
+                                                    children: /*#__PURE__*/ _jsx(Chip, {
+                                                        label: product.status,
+                                                        size: "small",
+                                                        color: (_STATUS_COLOR_product_status = STATUS_COLOR[product.status]) != null ? _STATUS_COLOR_product_status : 'default',
+                                                        variant: "outlined"
+                                                    })
+                                                }),
+                                                /*#__PURE__*/ _jsx(TableCell, {
+                                                    children: product.type
+                                                }),
+                                                /*#__PURE__*/ _jsx(TableCell, {
+                                                    children: CommerceModel.productPriceMissing(product) ? /*#__PURE__*/ _jsx(Chip, {
+                                                        label: "Set a price",
+                                                        size: "small",
+                                                        color: "warning",
+                                                        variant: "outlined"
+                                                    }) : formatPrice(product)
+                                                }),
+                                                /*#__PURE__*/ _jsxs(TableCell, {
+                                                    children: [
+                                                        formatStock(product),
+                                                        formatHeld(product) ? /*#__PURE__*/ _jsx(Typography, {
+                                                            variant: "caption",
+                                                            color: "text.secondary",
+                                                            component: "span",
+                                                            children: formatHeld(product)
+                                                        }) : null
+                                                    ]
+                                                }),
+                                                /*#__PURE__*/ _jsx(TableCell, {
+                                                    children: product.variants.length
+                                                }),
+                                                /*#__PURE__*/ _jsxs(TableCell, {
+                                                    align: "right",
+                                                    sx: {
+                                                        whiteSpace: 'nowrap'
+                                                    },
+                                                    children: [
+                                                        /*#__PURE__*/ _jsx(Button, {
+                                                            size: "small",
+                                                            onClick: ()=>setEditing(product),
+                                                            children: 'Edit'
+                                                        }),
+                                                        /*#__PURE__*/ _jsx(Button, {
+                                                            size: "small",
+                                                            onClick: handleDuplicate(product),
+                                                            children: 'Duplicate'
+                                                        }),
+                                                        product.type === 'digital' ? /*#__PURE__*/ _jsx(Button, {
+                                                            size: "small",
+                                                            onClick: ()=>setKeysFor(product),
+                                                            children: 'Keys'
+                                                        }) : null,
+                                                        CommerceModel.productInventory(product) != null ? /*#__PURE__*/ _jsx(Button, {
+                                                            size: "small",
+                                                            onClick: ()=>{
+                                                                var _ref, _ref1, _ref2;
+                                                                var _product_variants_find, _find, _;
+                                                                return setAdjusting({
+                                                                    product,
+                                                                    variantId: (_ref = (_product_variants_find = product.variants.find((variant)=>variant.inventory != null)) == null ? void 0 : _product_variants_find.id) != null ? _ref : product.variants[0].id,
+                                                                    delta: '',
+                                                                    reason: 'restock',
+                                                                    locationId: (_ref1 = (_ref2 = (_find = (locationDocs != null ? locationDocs : []).find((location)=>location.isDefault)) == null ? void 0 : _find.$id) != null ? _ref2 : (_ = (locationDocs != null ? locationDocs : [])[0]) == null ? void 0 : _.$id) != null ? _ref1 : ''
+                                                                });
+                                                            },
+                                                            children: 'Stock'
+                                                        }) : null,
+                                                        /*#__PURE__*/ _jsx(Button, {
+                                                            size: "small",
+                                                            onClick: handleStatus(product, product.status === 'archived' ? 'active' : 'archived'),
+                                                            children: product.status === 'archived' ? 'Activate' : 'Archive'
+                                                        }),
+                                                        /*#__PURE__*/ _jsx(Button, {
+                                                            size: "small",
+                                                            color: "error",
+                                                            onClick: handleDelete(product),
+                                                            children: 'Delete'
+                                                        })
+                                                    ]
+                                                })
+                                            ]
+                                        }, product.$id);
+                                    })
+                                })
+                            ]
+                        })
+                    }),
+                    products.length === 0 ? null : /*#__PURE__*/ _jsx(ListPagination, {
+                        page: page,
+                        pageSize: pageSize,
+                        rowCount: visibleProducts.length,
+                        // The rows matching the current filters, which the card holds in
+                        // full below the ceiling. NOT the catalog total — that is
+                        // `productCount`, and it answers a different question.
+                        count: products.length,
+                        onPageChange: setPage,
+                        onPageSizeChange: setPageSize
+                    }),
+                    catalogTruncated ? /*#__PURE__*/ _jsx(Alert, {
+                        severity: "info",
+                        children: `This table holds ${CATALOG_CEILING} products at a time and this ` + 'catalog is larger. Search reaches every product; the CSV ' + 'export covers what the table holds.'
+                    }) : null
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(keysFor),
+                onClose: ()=>setKeysFor(null),
+                maxWidth: "sm",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: `License keys — ${(_ref3 = keysFor == null ? void 0 : keysFor.name) != null ? _ref3 : ''}`
+                    }),
+                    /*#__PURE__*/ _jsx(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 2
+                        },
+                        children: (()=>{
+                            // The query already asked for this product's keys, so no second
+                            // filter here: narrowing a window that was already narrowed is how
+                            // a reader comes to believe the count covers the pool.
+                            const productKeys = (keyDocs != null ? keyDocs : []).slice(0, KEY_POOL_CEILING);
+                            const available = productKeys.filter((key)=>!key.assignedAtMs);
+                            // RETIRED KEYS ARE COUNTED SEPARATELY (AGL-2454). A refund retires
+                            // the key rather than returning it to the pool — the buyer already
+                            // holds the string, so reissuing it would give two people one
+                            // working key — and without this line the merchant simply watches
+                            // "available" fall with nothing to explain where the key went.
+                            const retired = productKeys.filter((key)=>key.revokedAtMs);
+                            const assigned = productKeys.length - available.length - retired.length;
+                            return /*#__PURE__*/ _jsxs(_Fragment, {
+                                children: [
+                                    /*#__PURE__*/ _jsx(Typography, {
+                                        variant: "body2",
+                                        color: "text.secondary",
+                                        sx: {
+                                            mt: 1
+                                        },
+                                        children: `${available.length} available · ${assigned} assigned` + (retired.length ? ` · ${retired.length} retired (refunded or revoked — not reissued)` : '') + (keyPoolTruncated ? `, of the ${KEY_POOL_CEILING} keys read` : '') + '. Keys deliver automatically on purchase (receipt + account).'
+                                    }),
+                                    available.slice(0, 8).map((key)=>/*#__PURE__*/ _jsxs(Stack, {
+                                            direction: "row",
+                                            spacing: 1,
+                                            sx: {
+                                                alignItems: 'center'
+                                            },
+                                            children: [
+                                                /*#__PURE__*/ _jsx(Typography, {
+                                                    variant: "caption",
+                                                    sx: {
+                                                        flex: 1,
+                                                        fontFamily: 'monospace'
+                                                    },
+                                                    noWrap: true,
+                                                    children: key.key
+                                                }),
+                                                /*#__PURE__*/ _jsx(Button, {
+                                                    size: "small",
+                                                    color: "error",
+                                                    onClick: ()=>updateDoc(doc(firestore, 'hosts', hostId, 'licenseKeys', key.$id), {
+                                                            revokedAtMs: Date.now(),
+                                                            assignedAtMs: Date.now()
+                                                        }),
+                                                    children: 'Revoke'
+                                                })
+                                            ]
+                                        }, key.$id)),
+                                    /*#__PURE__*/ _jsx(TextField, {
+                                        label: "Add keys (one per line)",
+                                        value: keysText,
+                                        onChange: (event)=>setKeysText(event.target.value),
+                                        size: "small",
+                                        multiline: true,
+                                        minRows: 3
+                                    })
+                                ]
+                            });
+                        })()
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                onClick: ()=>setKeysFor(null),
+                                children: 'Close'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                disabled: !keysText.trim(),
+                                onClick: async ()=>{
+                                    const keys = keysText.split('\n').map((key)=>key.trim()).filter(Boolean).slice(0, 200);
+                                    for (const key of keys){
+                                        await addDoc(collection(firestore, 'hosts', hostId, 'licenseKeys'), {
+                                            productId: keysFor.$id,
+                                            key,
+                                            assignedAtMs: null,
+                                            createdAtMs: Date.now()
+                                        });
+                                    }
+                                    setKeysText('');
+                                    enqueueSnackbar(`Added ${keys.length} keys`, {
+                                        variant: 'success',
+                                        persist: false
+                                    });
+                                },
+                                children: 'Add keys'
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(importing),
+                onClose: ()=>setImporting(null),
+                maxWidth: "sm",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: 'Import products (CSV)'
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 2
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                sx: {
+                                    mt: 1
+                                },
+                                children: 'Shopify-compatible columns (Handle, Title, Option/Variant ' + 'columns, Image Src). Paste the file contents or choose a file.'
+                            }),
+                            /*#__PURE__*/ _jsxs(Button, {
+                                component: "label",
+                                size: "small",
+                                sx: {
+                                    alignSelf: 'flex-start'
+                                },
+                                children: [
+                                    'Choose file',
+                                    /*#__PURE__*/ _jsx("input", {
+                                        type: "file",
+                                        accept: ".csv,text/csv",
+                                        hidden: true,
+                                        onChange: async (event)=>{
+                                            var _event_target_files;
+                                            const file = (_event_target_files = event.target.files) == null ? void 0 : _event_target_files[0];
+                                            if (!file) return;
+                                            const text = await file.text();
+                                            setImporting({
+                                                text,
+                                                parsed: CommerceModel.parseProductsCsv(text)
+                                            });
+                                        }
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "CSV",
+                                value: (_ref4 = importing == null ? void 0 : importing.text) != null ? _ref4 : '',
+                                onChange: (event)=>setImporting({
+                                        text: event.target.value,
+                                        parsed: event.target.value.trim() ? CommerceModel.parseProductsCsv(event.target.value) : null
+                                    }),
+                                size: "small",
+                                multiline: true,
+                                minRows: 5,
+                                maxRows: 10
+                            }),
+                            (importing == null ? void 0 : importing.parsed) ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                children: [
+                                    /*#__PURE__*/ _jsx(Typography, {
+                                        variant: "body2",
+                                        children: `Ready to import ${importing.parsed.products.length} products` + (importing.parsed.errors.length ? ` — ${importing.parsed.errors.length} rows skipped:` : '')
+                                    }),
+                                    importing.parsed.errors.slice(0, 5).map((error)=>/*#__PURE__*/ _jsx(Typography, {
+                                            variant: "caption",
+                                            color: "warning.main",
+                                            children: error
+                                        }, error))
+                                ]
+                            }) : null,
+                            WidgetSlot && (importing == null ? void 0 : (_importing_parsed = importing.parsed) == null ? void 0 : _importing_parsed.products.length) ? /*#__PURE__*/ _jsx(WidgetSlot, {
+                                slot: "productImport",
+                                hostId: hostId,
+                                orgId: undefined,
+                                count: importing.parsed.products.length,
+                                options: importOptions,
+                                setOption: setImportOption
+                            }) : null
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                onClick: ()=>setImporting(null),
+                                children: 'Cancel'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                disabled: !(importing == null ? void 0 : (_importing_parsed1 = importing.parsed) == null ? void 0 : _importing_parsed1.products.length),
+                                onClick: handleImportApply,
+                                children: `Import${(importing == null ? void 0 : (_importing_parsed2 = importing.parsed) == null ? void 0 : _importing_parsed2.products.length) ? ` ${importing.parsed.products.length}` : ''}`
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(adjusting),
+                onClose: ()=>setAdjusting(null),
+                maxWidth: "xs",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: `Adjust stock — ${(_ref5 = adjusting == null ? void 0 : adjusting.product.name) != null ? _ref5 : ''}`
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 2
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Variant",
+                                value: (_ref6 = adjusting == null ? void 0 : adjusting.variantId) != null ? _ref6 : '',
+                                onChange: (event)=>setAdjusting((prev)=>prev ? _extends({}, prev, {
+                                            variantId: event.target.value
+                                        }) : prev),
+                                size: "small",
+                                select: true,
+                                sx: {
+                                    mt: 1
+                                },
+                                children: ((_ref7 = adjusting == null ? void 0 : adjusting.product.variants) != null ? _ref7 : []).filter((variant)=>variant.inventory != null).map((variant)=>{
+                                    var _variant_options;
+                                    return /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: variant.id,
+                                        children: `${Object.values((_variant_options = variant.options) != null ? _variant_options : {}).join(' / ') || 'Default'} — ${variant.inventory} in stock${CommerceModel.heldVariantUnits(adjusting == null ? void 0 : adjusting.product, variant.id, nowMs) > 0 ? `, ${CommerceModel.heldVariantUnits(adjusting == null ? void 0 : adjusting.product, variant.id, nowMs)} reserved in checkout` : ''}`
+                                    }, variant.id);
+                                })
+                            }),
+                            ((_ref8 = locationDocs == null ? void 0 : locationDocs.length) != null ? _ref8 : 0) > 1 ? /*#__PURE__*/ _jsx(TextField, {
+                                label: "Location",
+                                value: (_ref9 = adjusting == null ? void 0 : adjusting.locationId) != null ? _ref9 : '',
+                                onChange: (event)=>setAdjusting((prev)=>prev ? _extends({}, prev, {
+                                            locationId: event.target.value
+                                        }) : prev),
+                                size: "small",
+                                select: true,
+                                children: (locationDocs != null ? locationDocs : []).map((location)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                        value: location.$id,
+                                        children: location.name
+                                    }, location.$id))
+                            }) : null,
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Change",
+                                placeholder: "+10 or -3",
+                                value: (_ref10 = adjusting == null ? void 0 : adjusting.delta) != null ? _ref10 : '',
+                                onChange: (event)=>setAdjusting((prev)=>prev ? _extends({}, prev, {
+                                            delta: event.target.value.replace(/[^0-9+-]/g, '')
+                                        }) : prev),
+                                size: "small"
+                            }),
+                            /*#__PURE__*/ _jsxs(TextField, {
+                                label: "Reason",
+                                value: (_ref11 = adjusting == null ? void 0 : adjusting.reason) != null ? _ref11 : 'restock',
+                                onChange: (event)=>setAdjusting((prev)=>prev ? _extends({}, prev, {
+                                            reason: event.target.value
+                                        }) : prev),
+                                size: "small",
+                                select: true,
+                                children: [
+                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: "restock",
+                                        children: 'Restock'
+                                    }),
+                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: "correction",
+                                        children: 'Correction'
+                                    }),
+                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: "damage",
+                                        children: 'Damaged'
+                                    }),
+                                    /*#__PURE__*/ _jsx(MenuItem, {
+                                        value: "refund",
+                                        children: 'Refund return'
+                                    })
+                                ]
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                onClick: ()=>setAdjusting(null),
+                                children: 'Cancel'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                disabled: !Math.round(Number(adjusting == null ? void 0 : adjusting.delta)),
+                                onClick: handleAdjustSave,
+                                children: 'Apply'
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(ProductEditorDialog, {
+                hostId: hostId,
+                product: editing,
+                // The editor is seeded from a row of THIS listener and replaces the
+                // whole document, so the freshness verdict belongs here (AGL-1358) —
+                // the dialog has no listener of its own to ask.
+                seedFromCache: productsFromCache,
+                seedUnreadable: productsStatus === 'error',
+                open: creating || editing !== null,
+                onClose: ()=>{
+                    setEditing(null);
+                    setCreating(false);
+                    // The dialog reports no verdict, so a create and a cancel look
+                    // the same from here. Re-reading on both is one aggregate and
+                    // keeps the cap off the dialog's shoulders (AGL-1716).
+                    setProductCountEpoch((epoch)=>epoch + 1);
+                }
+            }, (_ref12 = editing == null ? void 0 : editing.$id) != null ? _ref12 : creating ? 'new' : 'closed')
+        ]
+    });
+}
+ProductsHubCard.displayName = 'ProductsHubCard';
+export default ProductsHubCard;
+
+//# sourceMappingURL=products-hub-card.component.js.map