@mohasinac/appkit 4.38.0 → 4.39.1

package/dist/features/categories/repository/categories.repository.js

@@ -382,20 +382,42 @@ export class CategoriesRepository extends BaseRepository {
         }
     }
     /**
-     * Cloud Functions: full-overwrite category metrics (used by nightly reconciliation job).
+     * Cloud Functions: full-overwrite category metrics (nightly reconciliation).
+     *
+     * 🛑 THE OWN COUNT AND THE ROLLUP ARE SEPARATE ARGUMENTS, and they must be.
+     *
+     * This method used to take ONE pair of numbers and write it to both
+     * `productCount` and `totalProductCount` — so it could not express the
+     * distinction the live trigger (`updateMetricsInBatch`, just above) carefully
+     * maintains: `productCount` is the category's OWN items, `totalProductCount`
+     * is own + every descendant's. The nightly job therefore overwrote correct
+     * values with wrong ones every night:
+     *
+     *   - on a leaf it was accidentally right (a leaf has no descendants);
+     *   - on an ancestor it wrote the DESCENDANT sum into both, so a category
+     *     with 5 of its own and 15 below reported `productCount: 15` (should be
+     *     5) and `totalProductCount: 15` (should be 20 — its own 5 were never
+     *     added, because the caller's aggregate only walked other rows' leaves);
+     *   - on a row that is both a leaf and an ancestor, `setMetrics` was called
+     *     twice and last-write-won.
+     *
+     * Measured on production 2026-09-14 before the fix: **19 of 65 category rows
+     * disagreed with a recount**, every one of them low — the root read 56 against
+     * a true 65. Nothing errored, and no page looked broken; a wrong number is
+     * simply a number.
      */
-    async setMetrics(categoryId, productCount, auctionCount, productIds, auctionIds) {
+    async setMetrics(categoryId, m) {
         await this.db
             .collection(this.collection)
             .doc(categoryId)
             .update({
-            "metrics.productCount": productCount,
-            "metrics.auctionCount": auctionCount,
-            "metrics.totalProductCount": productCount,
-            "metrics.totalAuctionCount": auctionCount,
-            "metrics.totalItemCount": productCount + auctionCount,
-            "metrics.productIds": productIds,
-            "metrics.auctionIds": auctionIds,
+            "metrics.productCount": m.productCount,
+            "metrics.auctionCount": m.auctionCount,
+            "metrics.totalProductCount": m.totalProductCount,
+            "metrics.totalAuctionCount": m.totalAuctionCount,
+            "metrics.totalItemCount": m.totalProductCount + m.totalAuctionCount,
+            "metrics.productIds": m.productIds,
+            "metrics.auctionIds": m.auctionIds,
             "metrics.lastUpdated": new Date(),
             updatedAt: new Date(),
         });

package/dist/features/contact/email.js

@@ -13,6 +13,7 @@ function renderToStaticMarkup(el) {
 }
 import { normalizeError } from "../../errors/normalize";
 import { guardSend, logSuppressedSend } from "../../_internal/server/notifications/send-guard";
+import { recordSendAttempt } from "../../_internal/server/notifications/send-recorder";
 import { getProviders } from "../../contracts";
 import { createResendProvider } from "../../providers/email-resend/provider";
 import { siteSettingsRepository } from "../admin/repository/site-settings.repository";
@@ -94,6 +95,21 @@ export async function sendEmail(opts, guard) {
     const decision = await guardSend(guard);
     if (!decision.allow) {
         logSuppressedSend(guard, decision);
+        /*
+         * Record the SUPPRESSION, not just the sends. Six checklist cases assert that
+         * an email should NOT arrive, and over IMAP that is unprovable — you wait and
+         * hope. Here it is a row saying which rule stopped it. Gated to the harness
+         * mailbox; a no-op for everyone else. See send-recorder.ts.
+         */
+        void recordSendAttempt({
+            to: opts.to,
+            subject: typeof opts.subject === "string" ? opts.subject : "",
+            feature: guard.feature,
+            audience: String(guard.audience),
+            channel: String(guard.channel),
+            outcome: "suppressed",
+            reason: decision.reason,
+        });
         return { data: null, error: null, suppressed: decision.reason };
     }
     try {
@@ -112,11 +128,30 @@ export async function sendEmail(opts, guard) {
                 ? opts.headers
                 : undefined,
         });
+        void recordSendAttempt({
+            to: opts.to,
+            subject: typeof opts.subject === "string" ? opts.subject : "",
+            feature: guard.feature,
+            audience: String(guard.audience),
+            channel: String(guard.channel),
+            outcome: "sent",
+            html: typeof opts.html === "string" ? opts.html : undefined,
+        });
         return { data: data, error: null };
     }
     catch (error) {
         void normalizeError(error);
-        return { data: null, error: error instanceof Error ? error.message : String(error) };
+        const message = error instanceof Error ? error.message : String(error);
+        void recordSendAttempt({
+            to: opts.to,
+            subject: typeof opts.subject === "string" ? opts.subject : "",
+            feature: guard.feature,
+            audience: String(guard.audience),
+            channel: String(guard.channel),
+            outcome: "failed",
+            reason: message,
+        });
+        return { data: null, error: message };
     }
 }
 async function sendConfiguredEmail(opts, guard) {

package/dist/features/orders/repository/orders.repository.d.ts

@@ -162,7 +162,27 @@ declare class OrderRepository extends BaseRepository<OrderDocument> {
             canSort: boolean;
         };
     };
-    listForSeller(productIds: string[], model: SieveModel, opts?: {
+    /**
+     * A store's orders.
+     *
+     * 🛑 SCOPED BY `storeId`, NOT BY A LIST OF PRODUCT IDS.
+     *
+     * It used to take the seller's whole product list and run
+     * `.where(productId, "in", productIds)`. **Firestore caps `in` at 30 values**
+     * and nothing bounded that array, so the query threw `INVALID_ARGUMENT` and
+     * the route 500'd for any store past its 30th listing. Measured on production
+     * 2026-09-14: `store-beyblade-arena` has **65** products, so
+     * `GET /api/store/orders` — the seller's own order list — was permanently
+     * broken for the only real seller on the site, while the two small stores
+     * worked fine. A seller with 29 listings would never have reported it.
+     *
+     * `storeId` is the right key regardless of the cap: it is the field a cart is
+     * SPLIT on (one order per store), `findFulfillmentQueue` a few lines up
+     * already queries it, it is a registered sieve field, and 64/64 production
+     * orders carry it. It also deletes an entire products query per request from
+     * all four call sites — the route already resolved the store.
+     */
+    listForSeller(storeId: string, model: SieveModel, opts?: {
         search?: string;
     }): Promise<FirebaseSieveResult<OrderDocument>>;
     listForUser(userId: string, model: SieveModel): Promise<FirebaseSieveResult<OrderDocument>>;

package/dist/features/orders/repository/orders.repository.js

@@ -269,13 +269,33 @@ class OrderRepository extends BaseRepository {
             throw new DatabaseError(`Failed to delete orders for user: ${userId}`, error);
         }
     }
-    async listForSeller(productIds, model, opts) {
+    /**
+     * A store's orders.
+     *
+     * 🛑 SCOPED BY `storeId`, NOT BY A LIST OF PRODUCT IDS.
+     *
+     * It used to take the seller's whole product list and run
+     * `.where(productId, "in", productIds)`. **Firestore caps `in` at 30 values**
+     * and nothing bounded that array, so the query threw `INVALID_ARGUMENT` and
+     * the route 500'd for any store past its 30th listing. Measured on production
+     * 2026-09-14: `store-beyblade-arena` has **65** products, so
+     * `GET /api/store/orders` — the seller's own order list — was permanently
+     * broken for the only real seller on the site, while the two small stores
+     * worked fine. A seller with 29 listings would never have reported it.
+     *
+     * `storeId` is the right key regardless of the cap: it is the field a cart is
+     * SPLIT on (one order per store), `findFulfillmentQueue` a few lines up
+     * already queries it, it is a registered sieve field, and 64/64 production
+     * orders carry it. It also deletes an entire products query per request from
+     * all four call sites — the route already resolved the store.
+     */
+    async listForSeller(storeId, model, opts) {
         const plan = planSearchTxt(opts?.search);
         // A search that yielded no usable term must return NOTHING, not the
         // seller's whole order list.
         if (plan.empty)
             return emptySearchResult();
-        if (productIds.length === 0) {
+        if (!storeId) {
             const page = Math.max(1, Number(model.page ?? 1));
             const pageSize = Math.max(1, Number(model.pageSize ?? 20));
             return {
@@ -287,14 +307,11 @@ class OrderRepository extends BaseRepository {
                 hasMore: false,
             };
         }
-        let baseQuery = this.getCollection().where(ORDER_FIELDS.PRODUCT_ID, "in", productIds);
+        let baseQuery = this.getCollection().where(ORDER_FIELDS.STORE_ID, "==", storeId);
         if (plan.head) {
-            // `array-contains` alongside `in` is legal — Firestore's one-per-query
-            // limits are on `array-contains` and on the `in`/`not-in`/
-            // `array-contains-any` family separately, so one of each is fine.
-            // Verified against production data before this shipped, and the
-            // matching composite index is declared in firestore.indexes.json;
-            // the query happened to plan without one, which is not a guarantee.
+            // One `array-contains` alongside one equality is unconstrained —
+            // Firestore's per-query limits are on `array-contains` and on the
+            // `in`/`not-in`/`array-contains-any` family separately.
             baseQuery = baseQuery.where(ORDER_FIELDS.SEARCH_TXT, "array-contains", plan.head);
         }
         const result = await this.sieveQuery(model, OrderRepository.SELLER_SIEVE_FIELDS, {

package/dist/features/products/repository/products.repository.d.ts

@@ -12,6 +12,41 @@ export declare class ProductRepository extends BaseRepository<ProductDocument> {
     private cacheInvalidateForId;
     findById(id: string): Promise<ProductDocument | null>;
     protected mapDoc<D = ProductDocument>(snap: DocumentSnapshot): D;
+    /**
+     * Resolve a product's taxonomy into the shape every READ path expects:
+     * `categorySlugs` as the FULL ancestor chain (self first, root last), and a
+     * brand recorded as both its id and its display name.
+     *
+     * 🛑 WHY THIS LIVES IN THE REPOSITORY. The seller and admin create/update
+     * paths send a SINGLE category id (`category: "category-x-starters"`) — and
+     * `productCreateSchema` (src/validation/request-schemas.ts:129) declares only
+     * that scalar, with no `.passthrough()`, so an inbound `categorySlugs` array
+     * is stripped before it ever reaches Firestore. `mapDoc` then backfills
+     * `categorySlugs = [category]` **on read only**, which is invisible to a
+     * query: the category page runs `array-contains-any` against the STORED
+     * field, so a UI-created listing was unreachable from its own leaf category
+     * and from every ancestor of it. CLAUDE.md recorded the ancestor half of this
+     * as an outstanding follow-up; the leaf half was never noticed because every
+     * product in the database came from the seed, which hand-writes the chain
+     * (measured 2026-09-14: 95/95 products carried a correct chain, so the defect
+     * is LATENT — it fires the first time anyone creates a listing through the
+     * UI, which is precisely why no page looks broken today).
+     *
+     * There are ~14 independent write paths — two seller actions, two admin
+     * actions, four in `_internal/server/features/products/actions.ts`, the
+     * duplicate route, group-children, catalogue promotion, shipment linking and
+     * the WhatsApp import. Deriving at each one is Root Cause #75's shape: the
+     * copy made before a branch was added never learns about it. `create` and
+     * `update` are the only two methods every one of them funnels through.
+     *
+     * 🛑 It reads `categories` through `this.db` rather than importing
+     * `categoriesRepository`. No repository in this codebase imports another
+     * feature's repository, and the reason is the Turbopack import-chain trap
+     * (Root Cause #6/#18) — a raw collection read has neither problem.
+     */
+    private deriveTaxonomy;
+    /** The keys whose presence means a write could change the product's taxonomy. */
+    private static readonly TAXONOMY_KEYS;
     update(id: string, data: Partial<ProductDocument>): Promise<ProductDocument>;
     create(input: ProductCreateInput): Promise<ProductDocument>;
     findByStore(storeId: string): Promise<ProductDocument[]>;

package/dist/features/products/repository/products.repository.js

@@ -10,6 +10,9 @@ import { matchesAllSearchTerms, parseSearchTxtQuery, } from "../../../utils/sear
 // wrapper. Three copies existed and two were missing the same three fields.
 import { buildProductSearchTxt } from "../../../utils/search-txt-builders";
 import { PRODUCT_COLLECTION, ProductStatusValues } from "../schemas";
+// Collection NAME only — deliberately not `categoriesRepository`. See
+// deriveTaxonomy()'s header for why this is a raw read.
+import { CATEGORIES_COLLECTION } from "../../categories/schemas/firestore";
 import { PRODUCT_FIELDS } from "../../../constants/field-names";
 /**
  * Canonical listing-kind tokens used in `listingType`. Note: the public Sieve
@@ -92,12 +95,109 @@ export class ProductRepository extends BaseRepository {
         }
         return doc;
     }
+    /**
+     * Resolve a product's taxonomy into the shape every READ path expects:
+     * `categorySlugs` as the FULL ancestor chain (self first, root last), and a
+     * brand recorded as both its id and its display name.
+     *
+     * 🛑 WHY THIS LIVES IN THE REPOSITORY. The seller and admin create/update
+     * paths send a SINGLE category id (`category: "category-x-starters"`) — and
+     * `productCreateSchema` (src/validation/request-schemas.ts:129) declares only
+     * that scalar, with no `.passthrough()`, so an inbound `categorySlugs` array
+     * is stripped before it ever reaches Firestore. `mapDoc` then backfills
+     * `categorySlugs = [category]` **on read only**, which is invisible to a
+     * query: the category page runs `array-contains-any` against the STORED
+     * field, so a UI-created listing was unreachable from its own leaf category
+     * and from every ancestor of it. CLAUDE.md recorded the ancestor half of this
+     * as an outstanding follow-up; the leaf half was never noticed because every
+     * product in the database came from the seed, which hand-writes the chain
+     * (measured 2026-09-14: 95/95 products carried a correct chain, so the defect
+     * is LATENT — it fires the first time anyone creates a listing through the
+     * UI, which is precisely why no page looks broken today).
+     *
+     * There are ~14 independent write paths — two seller actions, two admin
+     * actions, four in `_internal/server/features/products/actions.ts`, the
+     * duplicate route, group-children, catalogue promotion, shipment linking and
+     * the WhatsApp import. Deriving at each one is Root Cause #75's shape: the
+     * copy made before a branch was added never learns about it. `create` and
+     * `update` are the only two methods every one of them funnels through.
+     *
+     * 🛑 It reads `categories` through `this.db` rather than importing
+     * `categoriesRepository`. No repository in this codebase imports another
+     * feature's repository, and the reason is the Turbopack import-chain trap
+     * (Root Cause #6/#18) — a raw collection read has neither problem.
+     */
+    async deriveTaxonomy(input) {
+        const out = {};
+        const cats = this.db.collection(CATEGORIES_COLLECTION);
+        const leaf = (Array.isArray(input.categorySlugs) && input.categorySlugs[0]) ||
+            input.category ||
+            null;
+        /*
+         * The brand selector's option value is the brand ROW's id (`brand-beyblade`),
+         * but `ProductDocument.brand` is matched by DISPLAY NAME —
+         * `BrandDetailPageView` filters `sieveFilter("brand", EQ, brand.name)`, and
+         * CLAUDE.md's § "Brand matching is by DISPLAY NAME" says so explicitly. So a
+         * seller-created listing stored `brand: "brand-beyblade"` while every seeded
+         * one stored `brand: "Beyblade"`, and the brand page matched neither the new
+         * row nor counted it. Resolving the id back to its name fixes that; a value
+         * that is ALREADY a display name does not resolve as a document id and is
+         * left exactly as it was.
+         */
+        const brandRef = input.brandSlug || input.brand || null;
+        const [catSnap, brandSnap] = await Promise.all([
+            leaf ? cats.doc(leaf).get() : Promise.resolve(null),
+            brandRef ? cats.doc(brandRef).get() : Promise.resolve(null),
+        ]);
+        if (catSnap?.exists) {
+            const cat = catSnap.data();
+            // `parentIds` is ordered root-first / nearest-last (category-tree.ts:107),
+            // and the stored chain is self-first / root-last. Reversing is what makes
+            // the derived value byte-identical to what the seed hand-writes — verified
+            // against products-standard-seed-data.ts:197.
+            out.categorySlugs = [leaf, ...(cat.parentIds ?? []).slice().reverse()];
+            out.category = leaf;
+            const names = [
+                cat.name,
+                ...(cat.ancestors ?? []).map((a) => a?.name).reverse(),
+            ].filter((n) => !!n);
+            if (names.length)
+                out.categoryNames = names;
+        }
+        else if (leaf) {
+            // Never destroy a chain we cannot improve on. A leaf that is not a real
+            // category row is a data problem to report, not a reason to blank the field.
+            serverLogger.warn("Product category id does not resolve to a category", {
+                leaf,
+            });
+        }
+        if (brandSnap?.exists) {
+            const brand = brandSnap.data();
+            if (brand.categoryType === "brand") {
+                out.brandSlug = brandRef;
+                if (brand.name)
+                    out.brand = brand.name;
+            }
+        }
+        return out;
+    }
     async update(id, data) {
         this.cacheInvalidateForId(id);
         const current = await super.findById(id);
-        const merged = { ...current, ...data };
+        /*
+         * Only re-derive when the write actually names a taxonomy field. Every
+         * stock decrement, view increment and status flip would otherwise pay two
+         * extra Firestore reads, which Rule #6 budgets at ~3 round-trips for a
+         * whole request.
+         */
+        const touchesTaxonomy = ProductRepository.TAXONOMY_KEYS.some((k) => k in data);
+        const derived = touchesTaxonomy
+            ? await this.deriveTaxonomy({ ...current, ...data })
+            : {};
+        const merged = { ...current, ...data, ...derived };
         const updated = await super.update(id, {
             ...data,
+            ...derived,
             searchTxt: buildProductSearchTxt(merged),
         });
         this.cacheSet(updated);
@@ -117,12 +217,18 @@ export class ProductRepository extends BaseRepository {
             }
         });
         const barcodeId = input.barcodeId ?? await generateBarcodeId(id);
+        // Always derive on create — one extra read per listing created, and it is
+        // what makes a UI-created product reachable from its own category page at
+        // all. A seed row already carrying the correct chain derives to the same
+        // value, so this is a no-op for every existing fixture.
+        const derived = await this.deriveTaxonomy(input);
+        const withTaxonomy = { ...input, ...derived };
         const productData = {
-            ...input,
+            ...withTaxonomy,
             barcodeId,
             slug: id,
             availableQuantity: input.stockQuantity,
-            searchTxt: buildProductSearchTxt(input),
+            searchTxt: buildProductSearchTxt(withTaxonomy),
             createdAt: new Date(),
             updatedAt: new Date(),
         };
@@ -525,6 +631,13 @@ export class ProductRepository extends BaseRepository {
     }
 }
 ProductRepository.CACHE_TTL_MS = 30000;
+/** The keys whose presence means a write could change the product's taxonomy. */
+ProductRepository.TAXONOMY_KEYS = [
+    "categorySlugs",
+    "category",
+    "brand",
+    "brandSlug",
+];
 ProductRepository.SIEVE_FIELDS = {
     id: { canFilter: true, canSort: false },
     title: { canFilter: true, canSort: true },

package/dist/features/products/schemas/firestore.d.ts

@@ -429,9 +429,46 @@ export type ProductUpdateInput = Partial<Pick<ProductDocument, (typeof PRODUCT_U
 export type ProductAdminUpdateInput = Partial<Omit<ProductDocument, "id" | "createdAt">>;
 export declare const PRODUCT_CODES_SUBCOLLECTION: "codes";
 export type ProductCodeStatus = "available" | "claimed" | "revoked";
+/**
+ * What the buyer actually receives. A "digital code" listing delivers digital
+ * CONTENT — a redemption string is only the commonest shape of it.
+ *
+ * `"code"` is the default and is what every pre-existing document is, so no
+ * migration is needed and no existing listing changes behaviour.
+ */
+export type ProductCodeContentKind = "code" | "image" | "file";
 export interface ProductCodeDocument extends BaseDocument {
     productId: string;
+    /**
+     * The redemption string. Required for `contentKind: "code"`, empty for the
+     * asset kinds — a QR is not a string.
+     */
     code: string;
+    /** Defaults to `"code"` when absent. */
+    contentKind?: ProductCodeContentKind;
+    /**
+     * 🛑 A RAW FIREBASE STORAGE PATH, NEVER a `/media/{slug}` URL, and never a
+     * signed URL.
+     *
+     * Two facts make this load-bearing:
+     *   - `storage.rules` is `allow read: if true` for every object in the
+     *     bucket, and
+     *   - `GET /api/media/[...slug]` applies NO authentication at all — it is a
+     *     bare exported handler with no session read, by design, because it
+     *     exists to serve public product photos through a watermarker.
+     *
+     * So anything reachable at a `/media/` slug is world-readable, and image
+     * filenames in this codebase are content-derived and therefore guessable.
+     * Putting a paid QR there would publish it. Instead the bytes are streamed by
+     * `GET /api/orders/{orderId}/code/asset`, which re-checks that the caller
+     * owns the order — the same shape as the invoice route, the one existing
+     * precedent for a gated download here.
+     */
+    assetPath?: string;
+    /** Original upload name, used for the `Content-Disposition` filename. */
+    fileName?: string;
+    /** Verified by magic bytes at upload, replayed as the response Content-Type. */
+    contentType?: string;
     status: ProductCodeStatus;
     orderId?: string;
     claimedByUserId?: string;

package/dist/features/reviews/repository/reviews.repository.d.ts

@@ -37,7 +37,7 @@ declare class ReviewRepository extends BaseRepository<ReviewDocument> {
      * it can be reasoned about).
      */
     findApprovedByProduct(productId: string, limit?: number): Promise<ReviewDocument[]>;
-    findApprovedByStore(storeId: string): Promise<ReviewDocument[]>;
+    findApprovedByStore(storeId: string, limit?: number): Promise<ReviewDocument[]>;
     findByUser(userId: string): Promise<ReviewDocument[]>;
     findApprovedByUser(userId: string): Promise<ReviewDocument[]>;
     findPending(): Promise<ReviewDocument[]>;

package/dist/features/reviews/repository/reviews.repository.js

@@ -101,13 +101,13 @@ class ReviewRepository extends BaseRepository {
         const snapshot = await query.get();
         return snapshot.docs.map((doc) => this.mapDoc(doc));
     }
-    async findApprovedByStore(storeId) {
+    async findApprovedByStore(storeId, limit = 50) {
         const snapshot = await this.db
             .collection(this.collection)
             .where(REVIEW_FIELDS.STORE_ID, "==", storeId)
             .where(REVIEW_FIELDS.STATUS, "==", "approved")
             .orderBy(REVIEW_FIELDS.CREATED_AT, "desc")
-            .limit(50)
+            .limit(limit)
             .get();
         return snapshot.docs.map((doc) => this.mapDoc(doc));
     }

package/dist/features/seller/actions/seller-actions.js

@@ -448,19 +448,10 @@ export async function listSellerOrders(userId, params) {
             hasMore: false,
         };
     }
-    const sellerProducts = await productRepository.findByStore(store.id);
-    const productIds = sellerProducts.map((p) => p.id);
-    if (productIds.length === 0) {
-        return {
-            items: [],
-            total: 0,
-            page: 1,
-            pageSize: params?.pageSize ?? 20,
-            totalPages: 0,
-            hasMore: false,
-        };
-    }
-    return orderRepository.listForSeller(productIds, {
+    // No products query: orders are scoped by `storeId`, the field a cart is
+    // split on. Fetching every product to build a `productId in [...]` clause was
+    // both an extra round trip and a hard 30-value Firestore cap.
+    return orderRepository.listForSeller(store.id, {
         filters: params?.filters,
         sorts: params?.sorts ?? "-createdAt",
         page: params?.page ?? 1,

package/dist/features/seller/components/SellerProductShell.d.ts

@@ -94,6 +94,12 @@ export interface SellerProductShellProps {
     listingType?: ProductListingMode;
     initialValues?: SellerProductDraft;
     productId?: string;
+    /**
+     * The digital-content pool manager, injected by the consumer so appkit never
+     * hard-codes an API path. Rendered in EDIT MODE only — a pool is keyed on a
+     * product id that does not exist until the listing has been created once.
+     */
+    renderDigitalContentPool?: (productId: string) => React.ReactNode;
     onSave: (draft: SellerProductDraft) => Promise<ProductActionResult>;
     onPublish: (draft: SellerProductDraft) => Promise<ProductActionResult>;
     onDiscard?: () => void;
@@ -129,4 +135,4 @@ export interface SellerProductShellProps {
      */
     previewSlot?: () => React.ReactNode;
 }
-export declare function SellerProductShell({ mode, listingType, initialValues, onSave, onPublish, onDiscard, isLoading, storeSlug, renderCategorySelector, renderBrandSelector, renderAddressSelector, renderTemplateSelector, onSaveAsTemplate, previewSlot, }: SellerProductShellProps): React.JSX.Element;
+export declare function SellerProductShell({ mode, listingType, initialValues, productId, onSave, onPublish, onDiscard, isLoading, storeSlug, renderCategorySelector, renderBrandSelector, renderAddressSelector, renderTemplateSelector, onSaveAsTemplate, previewSlot, renderDigitalContentPool, }: SellerProductShellProps): React.JSX.Element;

package/dist/features/seller/components/SellerProductShell.js

@@ -351,7 +351,13 @@ const EDIT_SECTIONS = [
     { id: "publish", label: "Publish" },
 ];
 // ── Main SellerProductShell ───────────────────────────────────────────────
-export function SellerProductShell({ mode, listingType = "standard", initialValues, onSave, onPublish, onDiscard, isLoading = false, storeSlug, renderCategorySelector, renderBrandSelector, renderAddressSelector, renderTemplateSelector, onSaveAsTemplate, previewSlot, }) {
+export function SellerProductShell({ mode, listingType = "standard", initialValues, 
+/*
+ * `productId` was declared on the props interface and NEVER DESTRUCTURED —
+ * dead from the day it was added, because nothing in the shell needed it.
+ * The digital-content pool is the first thing that does.
+ */
+productId, onSave, onPublish, onDiscard, isLoading = false, storeSlug, renderCategorySelector, renderBrandSelector, renderAddressSelector, renderTemplateSelector, onSaveAsTemplate, previewSlot, renderDigitalContentPool, }) {
     const [draft, setDraft] = useState(initialValues ?? { status: "draft", condition: "new" });
     const [formMode, setFormMode] = useState(mode === "create" && listingType === "standard" ? "quick" : "full");
     /*
@@ -583,5 +589,8 @@ export function SellerProductShell({ mode, listingType = "standard", initialValu
         ...EDIT_SECTIONS,
         ...(typeSpecificSection ? [{ id: typeSpecificSection.id, label: typeSpecificSection.label }] : []),
     ];
-    return (_jsx(FormShell, { isOpen: true, onClose: handleDiscard, title: title, breadcrumb: breadcrumb, isDirty: isDirty, isLoading: isLoading, sections: editSections, onSaveDraft: handleSave, onPublish: handlePublish, saveLabel: "Save Changes", publishLabel: "Update", previewSlot: previewSlot, footerTopSlot: _jsx(FormShellContext.Provider, { value: shellCtx, children: _jsx(FormErrorSummary, {}) }), children: _jsx(FormShellContext.Provider, { value: shellCtx, children: _jsxs(Stack, { gap: "lg", children: [_jsxs(Section, { id: "basic", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Basic Info" }), _jsx(StepBasic, { values: draft, onChange: update, renderCategorySelector: renderCategorySelector, renderBrandSelector: renderBrandSelector, renderTemplateSelector: renderTemplateSelector })] }), _jsxs(Section, { id: "media", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Media" }), _jsx(StepMedia, { values: draft, onChange: update, storeSlug: storeSlug })] }), typeSpecificSection && (_jsxs(Section, { id: typeSpecificSection.id, children: [_jsx(Heading, { level: 3, className: "mb-4", children: typeSpecificSection.sectionHeading ?? typeSpecificSection.label }), typeSpecificSection.render({ values: draft, onChange: update, errors: {} })] })), _jsxs(Section, { id: "pricing", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Pricing" }), _jsx(StepPricing, { values: draft, onChange: update, listingType: listingType })] }), _jsxs(Section, { id: "shipping", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Shipping" }), _jsx(StepShipping, { values: draft, onChange: update, renderAddressSelector: renderAddressSelector })] }), _jsxs(Section, { id: "returns", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Returns" }), _jsx(StepReturns, { values: draft, onChange: update })] }), _jsxs(Section, { id: "publish", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Publish" }), _jsx(StepPublish, { values: draft, onChange: update }), onSaveAsTemplate && (_jsxs(Div, { className: "mt-4 border-t border-[var(--appkit-color-border)]", padding: "t-md", children: [_jsx(Button, { type: "button", variant: "outline", size: "sm", onClick: () => onSaveAsTemplate(draft), children: "Save as Template" }), _jsx(Text, { className: "mt-1 text-[var(--appkit-color-secondary-text)]", size: "xs", children: "Save these settings as a reusable template for future listings." })] }))] })] }) }) }));
+    return (_jsx(FormShell, { isOpen: true, onClose: handleDiscard, title: title, breadcrumb: breadcrumb, isDirty: isDirty, isLoading: isLoading, sections: editSections, onSaveDraft: handleSave, onPublish: handlePublish, saveLabel: "Save Changes", publishLabel: "Update", previewSlot: previewSlot, footerTopSlot: _jsx(FormShellContext.Provider, { value: shellCtx, children: _jsx(FormErrorSummary, {}) }), children: _jsx(FormShellContext.Provider, { value: shellCtx, children: _jsxs(Stack, { gap: "lg", children: [_jsxs(Section, { id: "basic", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Basic Info" }), _jsx(StepBasic, { values: draft, onChange: update, renderCategorySelector: renderCategorySelector, renderBrandSelector: renderBrandSelector, renderTemplateSelector: renderTemplateSelector })] }), _jsxs(Section, { id: "media", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Media" }), _jsx(StepMedia, { values: draft, onChange: update, storeSlug: storeSlug })] }), typeSpecificSection && (_jsxs(Section, { id: typeSpecificSection.id, children: [_jsx(Heading, { level: 3, className: "mb-4", children: typeSpecificSection.sectionHeading ?? typeSpecificSection.label }), typeSpecificSection.render({ values: draft, onChange: update, errors: {} }), mode === "edit" &&
+                                listingType === "digital-code" &&
+                                productId &&
+                                renderDigitalContentPool?.(productId)] })), _jsxs(Section, { id: "pricing", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Pricing" }), _jsx(StepPricing, { values: draft, onChange: update, listingType: listingType })] }), _jsxs(Section, { id: "shipping", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Shipping" }), _jsx(StepShipping, { values: draft, onChange: update, renderAddressSelector: renderAddressSelector })] }), _jsxs(Section, { id: "returns", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Returns" }), _jsx(StepReturns, { values: draft, onChange: update })] }), _jsxs(Section, { id: "publish", children: [_jsx(Heading, { level: 3, className: "mb-4", children: "Publish" }), _jsx(StepPublish, { values: draft, onChange: update }), onSaveAsTemplate && (_jsxs(Div, { className: "mt-4 border-t border-[var(--appkit-color-border)]", padding: "t-md", children: [_jsx(Button, { type: "button", variant: "outline", size: "sm", onClick: () => onSaveAsTemplate(draft), children: "Save as Template" }), _jsx(Text, { className: "mt-1 text-[var(--appkit-color-secondary-text)]", size: "xs", children: "Save these settings as a reusable template for future listings." })] }))] })] }) }) }));
 }

package/dist/features/stores/api/[storeSlug]/reviews/route.d.ts

@@ -7,9 +7,14 @@
  * export { storeReviewsGET as GET } from "@mohasinac/feat-stores";
  * ```
  *
- * Aggregates approved reviews from up to 20 published products in a store.
+ * Aggregates every approved review filed against a store, by `storeId`.
  * Returns: reviews[], averageRating, totalReviews, ratingDistribution.
  *
+ * It used to aggregate "up to 20 published products by itemsSold" and fan out a
+ * review query per product — and since no product carries `itemsSold`, that
+ * `orderBy` matched nothing and the endpoint returned zero reviews for every
+ * store. See the block comment at the query for the full account.
+ *
  * Requires `db` registered in providers.config via `registerProviders()`.
  * Collections: "stores", "products", "reviews"
  */