@mohasinac/appkit 4.13.1 → 4.15.0

package/dist/features/store-extensions/schemas/shipping-config-form.d.ts

@@ -0,0 +1,148 @@
+import { z } from "zod";
+/**
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one.
+ */
+export declare const shippingConfigFormSchema: z.ZodEffects<z.ZodObject<{
+    label: z.ZodString;
+    method: z.ZodEnum<["free", "flat", "weight", "express", "pickup", "custom"]>;
+    flatRate: z.ZodOptional<z.ZodNumber>;
+    pricePerKg: z.ZodOptional<z.ZodNumber>;
+    freeAbove: z.ZodOptional<z.ZodNumber>;
+    expressSurcharge: z.ZodOptional<z.ZodNumber>;
+    estimatedDays: z.ZodOptional<z.ZodNumber>;
+    isDefault: z.ZodBoolean;
+    isActive: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    isDefault: boolean;
+    isActive: boolean;
+    method: "flat" | "weight" | "custom" | "free" | "express" | "pickup";
+    estimatedDays?: number | undefined;
+    freeAbove?: number | undefined;
+    flatRate?: number | undefined;
+    pricePerKg?: number | undefined;
+    expressSurcharge?: number | undefined;
+}, {
+    label: string;
+    isDefault: boolean;
+    isActive: boolean;
+    method: "flat" | "weight" | "custom" | "free" | "express" | "pickup";
+    estimatedDays?: number | undefined;
+    freeAbove?: number | undefined;
+    flatRate?: number | undefined;
+    pricePerKg?: number | undefined;
+    expressSurcharge?: number | undefined;
+}>, {
+    label: string;
+    isDefault: boolean;
+    isActive: boolean;
+    method: "flat" | "weight" | "custom" | "free" | "express" | "pickup";
+    estimatedDays?: number | undefined;
+    freeAbove?: number | undefined;
+    flatRate?: number | undefined;
+    pricePerKg?: number | undefined;
+    expressSurcharge?: number | undefined;
+}, {
+    label: string;
+    isDefault: boolean;
+    isActive: boolean;
+    method: "flat" | "weight" | "custom" | "free" | "express" | "pickup";
+    estimatedDays?: number | undefined;
+    freeAbove?: number | undefined;
+    flatRate?: number | undefined;
+    pricePerKg?: number | undefined;
+    expressSurcharge?: number | undefined;
+}>;
+export type ShippingConfigFormValues = z.infer<typeof shippingConfigFormSchema>;
+/** `storeId` is absent — the route sets it from the session, never the body. */
+export declare const shippingConfigCreateSchema: z.ZodEffects<z.ZodObject<{
+    label: z.ZodString;
+    method: z.ZodEnum<["free", "flat", "weight", "express", "pickup", "custom"]>;
+    flatRate: z.ZodOptional<z.ZodNumber>;
+    pricePerKg: z.ZodOptional<z.ZodNumber>;
+    freeAbove: z.ZodOptional<z.ZodNumber>;
+    expressSurcharge: z.ZodOptional<z.ZodNumber>;
+    estimatedDays: z.ZodOptional<z.ZodNumber>;
+    isDefault: z.ZodBoolean;
+    isActive: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    isDefault: boolean;
+    isActive: boolean;
+    method: "flat" | "weight" | "custom" | "free" | "express" | "pickup";
+    estimatedDays?: number | undefined;
+    freeAbove?: number | undefined;
+    flatRate?: number | undefined;
+    pricePerKg?: number | undefined;
+    expressSurcharge?: number | undefined;
+}, {
+    label: string;
+    isDefault: boolean;
+    isActive: boolean;
+    method: "flat" | "weight" | "custom" | "free" | "express" | "pickup";
+    estimatedDays?: number | undefined;
+    freeAbove?: number | undefined;
+    flatRate?: number | undefined;
+    pricePerKg?: number | undefined;
+    expressSurcharge?: number | undefined;
+}>, {
+    label: string;
+    isDefault: boolean;
+    isActive: boolean;
+    method: "flat" | "weight" | "custom" | "free" | "express" | "pickup";
+    estimatedDays?: number | undefined;
+    freeAbove?: number | undefined;
+    flatRate?: number | undefined;
+    pricePerKg?: number | undefined;
+    expressSurcharge?: number | undefined;
+}, {
+    label: string;
+    isDefault: boolean;
+    isActive: boolean;
+    method: "flat" | "weight" | "custom" | "free" | "express" | "pickup";
+    estimatedDays?: number | undefined;
+    freeAbove?: number | undefined;
+    flatRate?: number | undefined;
+    pricePerKg?: number | undefined;
+    expressSurcharge?: number | undefined;
+}>;
+/**
+ * Update contract — partial, and `.strict()` so an unknown key is a 400 rather
+ * than a silent write. The per-method completeness rules do not apply: a PATCH
+ * may legitimately carry only `isActive`.
+ */
+export declare const shippingConfigUpdateSchema: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    method: z.ZodOptional<z.ZodEnum<["free", "flat", "weight", "express", "pickup", "custom"]>>;
+    flatRate: z.ZodOptional<z.ZodNumber>;
+    pricePerKg: z.ZodOptional<z.ZodNumber>;
+    freeAbove: z.ZodOptional<z.ZodNumber>;
+    expressSurcharge: z.ZodOptional<z.ZodNumber>;
+    estimatedDays: z.ZodOptional<z.ZodNumber>;
+    zones: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    label?: string | undefined;
+    isDefault?: boolean | undefined;
+    isActive?: boolean | undefined;
+    method?: "flat" | "weight" | "custom" | "free" | "express" | "pickup" | undefined;
+    estimatedDays?: number | undefined;
+    freeAbove?: number | undefined;
+    flatRate?: number | undefined;
+    pricePerKg?: number | undefined;
+    expressSurcharge?: number | undefined;
+    zones?: string[] | undefined;
+}, {
+    label?: string | undefined;
+    isDefault?: boolean | undefined;
+    isActive?: boolean | undefined;
+    method?: "flat" | "weight" | "custom" | "free" | "express" | "pickup" | undefined;
+    estimatedDays?: number | undefined;
+    freeAbove?: number | undefined;
+    flatRate?: number | undefined;
+    pricePerKg?: number | undefined;
+    expressSurcharge?: number | undefined;
+    zones?: string[] | undefined;
+}>;

package/dist/features/store-extensions/schemas/shipping-config-form.js

@@ -0,0 +1,104 @@
+/*
+ * WHY: `POST /api/store/shipping-configs` spread the raw request body into
+ *      `.create()` and the PATCH handed it straight to `.update()` — no Zod on
+ *      either, and neither page validated anything. A shipping rule is money:
+ *      a `flatRate` of `"abc"`, a negative `freeAbove`, or an invented key are
+ *      all things that were persisted verbatim.
+ * WHAT: One schema for the pages AND the routes.
+ *
+ * ## The numeric fields are `.coerce` on purpose
+ *
+ * The pages hold them as strings from `<input type="number">`. Coercing here
+ * rather than at each call site means every consumer gets a real number and
+ * no page has to remember a `Number()` cast — the kind of per-callsite
+ * conversion that produces a `NaN` in Firestore the first time someone forgets.
+ *
+ * EXPORTS:
+ *   shippingConfigFormSchema, shippingConfigCreateSchema,
+ *   shippingConfigUpdateSchema, type ShippingConfigFormValues
+ *
+ * @tag domain:store-extensions
+ * @tag layer:schema
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:store/shipping-configs pages,/api/store/shipping-configs
+ * @tag sideEffects:none
+ */
+import { z } from "zod";
+import { annotate } from "../../shell/field-ui-meta";
+/** Mirrors `ShippingMethod` in ./firestore. */
+const shippingMethodSchema = z.enum(["free", "flat", "weight", "express", "pickup", "custom"]);
+/** A non-negative money/threshold amount, coerced from the form's string. */
+const amount = (label) => z.coerce.number({ invalid_type_error: `${label} must be a number.` }).min(0, `${label} cannot be negative.`);
+/**
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one.
+ */
+export const shippingConfigFormSchema = z
+    .object({
+    label: annotate(z.string().min(1, "Give this rule a name.").max(80), {
+        section: "basics", sectionLabel: "Shipping Rule", sectionRequired: true,
+        quick: true, order: 1, row: "pair",
+    }),
+    method: annotate(shippingMethodSchema, {
+        section: "basics", quick: true, order: 2, row: "pair",
+    }),
+    flatRate: annotate(amount("Flat rate").optional(), {
+        section: "rates", sectionLabel: "Rates", order: 1, row: "pair",
+    }),
+    pricePerKg: annotate(amount("Price per kg").optional(), {
+        section: "rates", order: 2, row: "pair",
+    }),
+    freeAbove: annotate(amount("Free above").optional(), {
+        section: "rates", order: 3, row: "pair",
+    }),
+    expressSurcharge: annotate(amount("Express surcharge").optional(), {
+        section: "rates", order: 4, row: "pair",
+    }),
+    estimatedDays: annotate(z.coerce.number().int("Estimated days must be a whole number.").min(0).max(365).optional(), { section: "rates", order: 5, row: "pair" }),
+    isDefault: annotate(z.boolean(), {
+        section: "visibility", sectionLabel: "Visibility", order: 1, row: "quarter",
+    }),
+    isActive: annotate(z.boolean(), {
+        section: "visibility", order: 2, row: "quarter",
+    }),
+})
+    .superRefine((v, ctx) => {
+    // A rate rule with no rate is not a rule. Checked per method, because the
+    // required field differs and a blanket `.min(1)` would make every rate
+    // mandatory for a free/pickup rule that has none.
+    const need = (path, label) => {
+        if (v[path] == null) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [path],
+                message: `A "${label}" rule needs a ${path === "flatRate" ? "flat rate" : "price per kg"}.`,
+            });
+        }
+    };
+    if (v.method === "flat")
+        need("flatRate", "flat");
+    if (v.method === "weight")
+        need("pricePerKg", "weight");
+});
+/** `storeId` is absent — the route sets it from the session, never the body. */
+export const shippingConfigCreateSchema = shippingConfigFormSchema;
+/**
+ * Update contract — partial, and `.strict()` so an unknown key is a 400 rather
+ * than a silent write. The per-method completeness rules do not apply: a PATCH
+ * may legitimately carry only `isActive`.
+ */
+export const shippingConfigUpdateSchema = z
+    .object({
+    label: z.string().min(1).max(80).optional(),
+    method: shippingMethodSchema.optional(),
+    flatRate: amount("Flat rate").optional(),
+    pricePerKg: amount("Price per kg").optional(),
+    freeAbove: amount("Free above").optional(),
+    expressSurcharge: amount("Express surcharge").optional(),
+    estimatedDays: z.coerce.number().int().min(0).max(365).optional(),
+    zones: z.array(z.string()).optional(),
+    isDefault: z.boolean().optional(),
+    isActive: z.boolean().optional(),
+})
+    .strict();

package/dist/features/store-extensions/schemas/store-category-form.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+/**
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one, so annotating
+ * before `.optional()` silently loses the metadata.
+ */
+export declare const storeCategoryFormSchema: z.ZodObject<{
+    label: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    coverImageUrl: z.ZodOptional<z.ZodString>;
+    displayOrder: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    displayOrder: number;
+    description?: string | undefined;
+    slug?: string | undefined;
+    coverImageUrl?: string | undefined;
+}, {
+    label: string;
+    displayOrder: number;
+    description?: string | undefined;
+    slug?: string | undefined;
+    coverImageUrl?: string | undefined;
+}>;
+export type StoreCategoryFormValues = z.infer<typeof storeCategoryFormSchema>;
+/**
+ * The server's create contract.
+ *
+ * Identical fields, but `slug` is REQUIRED here: the client derives it from
+ * the label when blank, and a category with no slug has no URL. Keeping the
+ * derivation on the client and the requirement on the server means the route
+ * never has to guess what the user meant.
+ */
+export declare const storeCategoryCreateSchema: z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    coverImageUrl: z.ZodOptional<z.ZodString>;
+    displayOrder: z.ZodNumber;
+} & {
+    slug: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    slug: string;
+    displayOrder: number;
+    description?: string | undefined;
+    coverImageUrl?: string | undefined;
+}, {
+    label: string;
+    slug: string;
+    displayOrder: number;
+    description?: string | undefined;
+    coverImageUrl?: string | undefined;
+}>;

package/dist/features/store-extensions/schemas/store-category-form.js

@@ -0,0 +1,73 @@
+/*
+ * WHY: `/store/categories/new` collected five fields through raw <Input>s with
+ *      no <Form>, no schema and no check of any kind, and `POST
+ *      /api/store/categories` spread the raw request body straight into
+ *      `storeCategoriesRepository.create()`. Neither side validated anything,
+ *      so an entirely empty storefront category could be created — and any
+ *      extra key a caller sent was written verbatim into Firestore.
+ * WHAT: One schema for both sides. The client parses it to show inline errors
+ *       before submitting; the route parses it to decide what is allowed to
+ *       reach the database.
+ *
+ * ## Why one schema and not two
+ *
+ * A client copy and a server copy of the same rules is how they come to
+ * disagree — and when they do, the client's is the one users see while the
+ * server's is the one that decides. The route strips unknown keys BECAUSE it
+ * parses this: `storeId` is set from the session, never from the body, so a
+ * caller cannot write a category into someone else's store by adding a field.
+ *
+ * `productIds` and `isActive` are deliberately absent: they are managed after
+ * creation (assigning products, toggling visibility), not typed into the
+ * create form, and the repository supplies their defaults.
+ *
+ * EXPORTS:
+ *   storeCategoryFormSchema, storeCategoryCreateSchema,
+ *   type StoreCategoryFormValues
+ *
+ * @tag domain:store-extensions
+ * @tag layer:schema
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:store/categories/new,POST /api/store/categories
+ * @tag sideEffects:none
+ */
+import { z } from "zod";
+import { annotate } from "../../shell/field-ui-meta";
+/**
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one, so annotating
+ * before `.optional()` silently loses the metadata.
+ */
+export const storeCategoryFormSchema = z.object({
+    label: annotate(z.string().min(1, "Label is required").max(80, "Keep the label under 80 characters."), {
+        section: "basics", sectionLabel: "Category", sectionRequired: true,
+        quick: true, order: 1, row: "full",
+    }),
+    slug: annotate(z.string().max(80, "Keep the slug under 80 characters.").optional(), {
+        section: "basics", order: 2, row: "full",
+        // T1 calculated: derived from the label when left blank, then frozen —
+        // the same create-only rule every other slug in this codebase follows,
+        // because renaming one breaks inbound links.
+        tier: "t1-derive",
+        help: "Left blank, this is generated from the label.",
+    }),
+    description: annotate(z.string().max(500, "Keep the description under 500 characters.").optional(), {
+        section: "basics", order: 3, row: "full",
+    }),
+    coverImageUrl: annotate(z.string().optional(), {
+        section: "media", sectionLabel: "Media", order: 1, row: "full", kind: "media",
+    }),
+    displayOrder: annotate(z.coerce.number().int("Display order must be a whole number.").min(0, "Display order cannot be negative."), { section: "visibility", sectionLabel: "Visibility", order: 1, row: "pair" }),
+});
+/**
+ * The server's create contract.
+ *
+ * Identical fields, but `slug` is REQUIRED here: the client derives it from
+ * the label when blank, and a category with no slug has no URL. Keeping the
+ * derivation on the client and the requirement on the server means the route
+ * never has to guess what the user meant.
+ */
+export const storeCategoryCreateSchema = storeCategoryFormSchema.extend({
+    slug: z.string().min(1, "Slug is required").max(80),
+});

package/dist/features/stores/api/[storeSlug]/route.js

@@ -13,6 +13,7 @@
  */
 import { NextResponse } from "next/server.js";
 import { getProviders } from "../../../../contracts";
+import { toStoreDetail } from "../../../../_internal/server/features/stores/adapters";
 import { normalizeError } from "../../../../errors/normalize";
 // --- GET /api/stores/[storeSlug] ---------------------------------------------
 export async function GET(_request, context) {
@@ -33,31 +34,7 @@ export async function GET(_request, context) {
             return NextResponse.json({ success: false, error: "Store not found" }, { status: 404 });
         }
         // Map to public-safe StoreDetail shape (strip internal/sensitive fields)
-        const store = {
-            id: raw.id,
-            storeSlug: raw.storeSlug,
-            ownerId: raw.ownerId,
-            storeName: raw.storeName,
-            storeDescription: raw.storeDescription,
-            storeCategory: raw.storeCategory,
-            storeLogoURL: raw.storeLogoURL,
-            storeBannerURL: raw.storeBannerURL,
-            status: raw.status,
-            isPublic: raw.isPublic,
-            totalProducts: raw.stats?.totalProducts ?? raw.totalProducts ?? undefined,
-            itemsSold: raw.stats?.itemsSold ?? raw.itemsSold ?? undefined,
-            totalReviews: raw.stats?.totalReviews ?? raw.totalReviews ?? undefined,
-            averageRating: raw.stats?.averageRating ?? raw.averageRating,
-            bio: raw.bio,
-            location: raw.location,
-            website: raw.website,
-            socialLinks: raw.socialLinks,
-            returnPolicy: raw.returnPolicy,
-            shippingPolicy: raw.shippingPolicy,
-            isVacationMode: raw.isVacationMode,
-            vacationMessage: raw.vacationMessage,
-            createdAt: raw.createdAt,
-        };
+        const store = toStoreDetail(raw);
         return NextResponse.json({ success: true, data: store });
     }
     catch (error) {

package/dist/features/stores/components/StoreAuctionsListing.js

@@ -13,6 +13,10 @@ import { getDefaultCurrency } from "../../../core/baseline-resolver";
 import { useGuestWishlist } from "../../wishlist/hooks/useGuestWishlist";
 import { pushWishlistOp } from "../../cart/utils/pending-ops";
 import { AUCTION_PUBLIC_SORT_OPTIONS } from "../../products/constants/sieve";
+import { AvailabilityTabs } from "../../products/components/AvailabilityTabs";
+import { AVAILABILITY_VALUES } from "../../../constants/field-names";
+import { TABLE_KEYS } from "../../../constants/table-keys";
+const STORE_AUCTION_TYPES = ["auction"];
 const __P = {
     p3: "p-[var(--appkit-space-3)]",
 };
@@ -45,6 +49,12 @@ export function StoreAuctionsListing({ storeId, initialData }) {
     const hasActiveState = !!table.get("q") ||
         table.get("sort") !== DEFAULT_SORT ||
         filterActiveCount > 0;
+    // Absent means "available" — the same default `listStoreProducts`
+    // resolves server-side. These six store tabs sent NO availability
+    // param at all until 2026-08-24, while their SSR fetch did apply one,
+    // so any client refetch silently widened the list (Root Cause #30).
+    const availability = table.get(TABLE_KEYS.AVAILABILITY) ||
+        AVAILABILITY_VALUES.AVAILABLE;
     const params = {
         q: table.get("q") || undefined,
         minBid: table.get("minBid") ? Number(table.get("minBid")) : undefined,
@@ -56,6 +66,7 @@ export function StoreAuctionsListing({ storeId, initialData }) {
         perPage: table.getNumber("pageSize", 24),
         storeId: storeId || undefined,
         listingType: "auction",
+        availability,
     };
     const { products: rawAuctions, totalPages, page, isLoading } = useProducts(params, { initialData });
     const auctions = rawAuctions.map((p) => ({
@@ -75,6 +86,9 @@ export function StoreAuctionsListing({ storeId, initialData }) {
         status: p.status,
         slug: p.slug,
         buyNowPrice: p.buyNowPrice,
+        // Read by isBuyNowAvailable() on the card — without it a sold auction still
+        // offers a Buyout chip.
+        isSold: p.isSold,
     }));
     const commitSearch = useCallback(() => {
         // table.set("q", v) already resets page to 1 — see root-cause #13.
@@ -107,7 +121,7 @@ export function StoreAuctionsListing({ storeId, initialData }) {
                         return;
                     setView(v);
                     table.set("view", v);
-                }, onResetAll: resetAll, hasActiveState: hasActiveState }), totalPages > 1 && (_jsx(StickyToolbar, { offset: "header+pagination", tone: "translucent", border: true, padding: "toolbar", children: _jsx(Row, { justify: "center", children: _jsx(Pagination, { currentPage: page, totalPages: totalPages, onPageChange: (p) => table.setPage(p) }) }) })), _jsx(Div, { padding: "y-lg", children: isLoading ? (_jsx(Div, { className: gridClass, children: Array.from({ length: 8 }).map((_, i) => (_jsxs(Div, { className: "overflow-hidden animate-pulse", border: "subtle", rounded: "xl", children: [_jsx(Div, { className: "aspect-square", surface: "subtle" }), _jsxs(Stack, { className: `${__P.p3}`, gap: "sm", children: [_jsx(Div, { className: "h-3 w-3/4", surface: "subtle", rounded: "default" }), _jsx(Div, { className: "h-4 w-1/2", surface: "subtle", rounded: "default" }), _jsx(Div, { className: "h-8", surface: "subtle", rounded: "default" })] })] }, i))) })) : (_jsx(MarketplaceAuctionGrid, { auctions: auctions, variant: view === "list" ? "list" : "grid", gridClassName: view === "list" ? "flex flex-col gap-[var(--appkit-space-4)]" : gridClass, wishlistActions: wishlistActions, labels: {
+                }, onResetAll: resetAll, hasActiveState: hasActiveState }), _jsx(Div, { padding: "y-sm", children: _jsx(AvailabilityTabs, { types: STORE_AUCTION_TYPES }) }), totalPages > 1 && (_jsx(StickyToolbar, { offset: "header+pagination", tone: "translucent", border: true, padding: "toolbar", children: _jsx(Row, { justify: "center", children: _jsx(Pagination, { currentPage: page, totalPages: totalPages, onPageChange: (p) => table.setPage(p) }) }) })), _jsx(Div, { padding: "y-lg", children: isLoading ? (_jsx(Div, { className: gridClass, children: Array.from({ length: 8 }).map((_, i) => (_jsxs(Div, { className: "overflow-hidden animate-pulse", border: "subtle", rounded: "xl", children: [_jsx(Div, { className: "aspect-square", surface: "subtle" }), _jsxs(Stack, { className: `${__P.p3}`, gap: "sm", children: [_jsx(Div, { className: "h-3 w-3/4", surface: "subtle", rounded: "default" }), _jsx(Div, { className: "h-4 w-1/2", surface: "subtle", rounded: "default" }), _jsx(Div, { className: "h-8", surface: "subtle", rounded: "default" })] })] }, i))) })) : (_jsx(MarketplaceAuctionGrid, { auctions: auctions, variant: view === "list" ? "list" : "grid", gridClassName: view === "list" ? "flex flex-col gap-[var(--appkit-space-4)]" : gridClass, wishlistActions: wishlistActions, labels: {
                         emptyTitle: "No auctions yet",
                         emptyDescription: "This store has no active auctions.",
                     } })) }), _jsx(FilterDrawer, { open: filterOpen, onOpen: openFilters, onClose: () => setFilterOpen(false), onApply: applyFilters, onReset: onFilterClear, activeCount: filterActiveCount, hideTrigger: true, children: _jsx(AuctionFilters, { table: pendingTable, currencyPrefix: "\u20B9" }) }), _jsx(LoginRequiredModal, { isOpen: modalOpen, onClose: closeModal, message: modalMessage })] }));

package/dist/features/stores/components/StoreClassifiedsListing.js

@@ -8,9 +8,12 @@ import { Div, FilterDrawer, ListingToolbar, Pagination, Row, Text, StickyToolbar
 import { ClassifiedFilters } from "../../classified/components/ClassifiedFilters";
 import { InteractiveProductCard } from "../../products/components/InteractiveProductCard";
 import { PRODUCT_FIELDS } from "../../../constants/field-names";
-import { TABLE_KEYS } from "../../../constants/table-keys";
 import { sortBy } from "../../../constants/sort";
 import { ROUTES } from "../../../next";
+import { AvailabilityTabs } from "../../products/components/AvailabilityTabs";
+import { AVAILABILITY_VALUES } from "../../../constants/field-names";
+import { TABLE_KEYS } from "../../../constants/table-keys";
+const STORE_CLASSIFIED_TYPES = ["classified"];
 const DEFAULT_SORT = sortBy(PRODUCT_FIELDS.CREATED_AT);
 const SORT_OPTIONS = [
     { value: sortBy(PRODUCT_FIELDS.CREATED_AT), label: "Newest First" },
@@ -28,6 +31,12 @@ export function StoreClassifiedsListing({ storeId, initialData }) {
     const applyFilters = useCallback(() => { onFilterApply(); setFilterOpen(false); }, [onFilterApply]);
     const resetAll = useCallback(() => { onResetAll({ q: "", sort: "" }); setSearchInput(""); }, [onResetAll]);
     const hasActiveState = !!table.get("q") || table.get("sort") !== DEFAULT_SORT || filterActiveCount > 0;
+    // Absent means "available" — the same default `listStoreProducts`
+    // resolves server-side. These six store tabs sent NO availability
+    // param at all until 2026-08-24, while their SSR fetch did apply one,
+    // so any client refetch silently widened the list (Root Cause #30).
+    const availability = table.get(TABLE_KEYS.AVAILABILITY) ||
+        AVAILABILITY_VALUES.AVAILABLE;
     const params = {
         q: table.get("q") || undefined,
         minPrice: table.get(TABLE_KEYS.MIN_PRICE) ? Number(table.get(TABLE_KEYS.MIN_PRICE)) : undefined,
@@ -44,10 +53,11 @@ export function StoreClassifiedsListing({ storeId, initialData }) {
             [TABLE_KEYS.NEGOTIABLE]: table.get(TABLE_KEYS.NEGOTIABLE),
             [TABLE_KEYS.ACCEPTS_SHIPPING]: table.get(TABLE_KEYS.ACCEPTS_SHIPPING),
         },
+        availability,
     };
     const { products, totalPages, page, isLoading } = useProducts(params, { initialData });
     const gridClass = "grid grid-cols-2 sm:grid-cols-3 lg:grid-cols-4 gap-[var(--appkit-space-4)]";
-    return (_jsxs(Div, { className: "min-h-[200px]", children: [_jsx(ListingToolbar, { filterCount: filterActiveCount, onFiltersClick: openFilters, searchValue: searchInput, searchPlaceholder: "Search store classifieds\u2026", onSearchChange: setSearchInput, onSearchCommit: () => table.set("q", searchInput.trim()), sortValue: table.get("sort") || DEFAULT_SORT, sortOptions: SORT_OPTIONS, onSortChange: (v) => table.set("sort", v), onResetAll: resetAll, hasActiveState: hasActiveState }), totalPages > 1 && (_jsx(StickyToolbar, { offset: "header+pagination", tone: "translucent", border: true, padding: "toolbar", children: _jsx(Row, { justify: "center", children: _jsx(Pagination, { currentPage: page, totalPages: totalPages, onPageChange: (p) => table.setPage(p) }) }) })), _jsx(Div, { padding: "y-lg", children: _jsx(Div, { className: gridClass, children: isLoading
+    return (_jsxs(Div, { className: "min-h-[200px]", children: [_jsx(ListingToolbar, { filterCount: filterActiveCount, onFiltersClick: openFilters, searchValue: searchInput, searchPlaceholder: "Search store classifieds\u2026", onSearchChange: setSearchInput, onSearchCommit: () => table.set("q", searchInput.trim()), sortValue: table.get("sort") || DEFAULT_SORT, sortOptions: SORT_OPTIONS, onSortChange: (v) => table.set("sort", v), onResetAll: resetAll, hasActiveState: hasActiveState }), _jsx(Div, { padding: "y-sm", children: _jsx(AvailabilityTabs, { types: STORE_CLASSIFIED_TYPES }) }), totalPages > 1 && (_jsx(StickyToolbar, { offset: "header+pagination", tone: "translucent", border: true, padding: "toolbar", children: _jsx(Row, { justify: "center", children: _jsx(Pagination, { currentPage: page, totalPages: totalPages, onPageChange: (p) => table.setPage(p) }) }) })), _jsx(Div, { padding: "y-lg", children: _jsx(Div, { className: gridClass, children: isLoading
                         ? Array.from({ length: 8 }).map((_, i) => _jsx(Div, { surface: "muted", rounded: "xl", className: "aspect-square animate-pulse" }, i))
                         : products.length === 0
                             ? _jsx(Div, { paddingY: "y-4xl", className: "col-span-full text-left", children: _jsx(Text, { color: "muted", children: "No classified listings in this store yet." }) })