@mohasinac/appkit 4.52.5 → 4.53.1

package/dist/features/search/hooks/useSiteSearch.js

@@ -0,0 +1,149 @@
+"use client";
+/*
+ * WHY: One query, one matcher, two surfaces — the header dropdown and
+ *      `/search` must not grow separate notions of what matches.
+ * WHAT: The client search hook. Runs the browser matcher over the loaded
+ *       artifact and returns BOTH shapes: grouped results for the page and
+ *       flat suggestion rows for the typeahead.
+ *
+ * ## 🛑 Synchronous per keystroke, and no debounce
+ *
+ * There is nothing to debounce — a debounce exists to avoid spending a
+ * network round trip per character, and this spends none. `searchIndex` is a
+ * linear scan over ~3,700 prepared records, measured sub-millisecond by
+ * `verify-search-local.mjs`. Adding a 250 ms debounce here would make the box
+ * feel SLOWER than the thing it replaced while costing nothing less.
+ *
+ * The one thing that is async is loading the artifact, once, and `active`
+ * gates that (see `useSearchIndex`).
+ *
+ * ## 🛑 No minimum query length either
+ *
+ * `useNavSuggestions` gates at 3 characters because each query is a real
+ * Firestore round trip and below that the result is dominated by whatever
+ * sorts first. Neither clause holds here: a one-character query costs the
+ * same nothing, and the matcher ranks rather than truncates. Typing "d" and
+ * seeing something is the behaviour a local index is FOR.
+ *
+ * ## It returns a result even when the index is not in play
+ *
+ * `status` distinguishes `idle` / `loading` / `ready` / `failed` / `disabled`,
+ * and the last two mean *the caller should fall back*, not *show nothing*.
+ * A caller that renders an empty state on `loading` is saying "nothing
+ * matched" about a question that has not been asked yet.
+ *
+ * @tag domain:search
+ * @tag layer:feature
+ * @tag pattern:hook
+ * @tag access:client
+ * @tag consumers:Search,SearchResultsClient
+ * @tag sideEffects:none
+ */
+import * as React from "react";
+import { searchIndex } from "../../../_internal/shared/search/match.js";
+import { countFacets, moreHrefResolver, toSearchResult, } from "../../../_internal/shared/search/to-groups.js";
+import { parseSearchTxtQuery } from "../../../utils/search-txt.js";
+import { useSearchIndex } from "./useSearchIndex.js";
+/**
+ * How many hits the matcher is asked for.
+ *
+ * Generous because grouping happens AFTER: a cap of 20 on a query matching
+ * 400 products would starve every other group, since the list is
+ * score-ordered and products would fill it. 200 keeps the long tail of types
+ * reachable while staying trivial to sort.
+ */
+const MATCH_LIMIT = 200;
+/**
+ * `typeKey` -> the five values the header dropdown's icon and badge maps
+ * understand.
+ *
+ * 🛑 A MAPPING rather than a widening of `NavSuggestionRecord["type"]`.
+ * That union is public API and is switched on by the dropdown's
+ * `DEFAULT_TYPE_ICONS` / `DEFAULT_TYPE_BADGES`; widening it to `string` would
+ * compile everywhere and silently render unstyled rows for the 16 index types
+ * those maps have never heard of (Root Cause #20). The real key travels
+ * alongside, in `typeKey`, for anything that wants it.
+ */
+function suggestionTypeFor(typeKey) {
+    switch (typeKey) {
+        case "blog":
+            return "blog";
+        case "event":
+            return "event";
+        case "category":
+        case "brand":
+        case "franchise":
+        case "bundle":
+        case "model":
+        case "part":
+            return "category";
+        case "store":
+        case "faq":
+        case "review":
+        case "scammer":
+        case "coupon":
+        case "group":
+            return "page";
+        default:
+            // Every listing type — product, auction, pre-order, … — plus anything
+            // added to the index later. A listing is the commonest row and the
+            // product icon is the right default for an unknown one.
+            return "product";
+    }
+}
+export function useSiteSearch(query, { active, indexEnabled, types, facets, label }) {
+    const { status, index } = useSearchIndex({ active, indexEnabled });
+    /*
+     * 🛑 `types` and `facets` are arrays, so a caller passing a literal creates
+     * a new identity every render and would re-run the scan on every keystroke
+     * of an UNCHANGED filter. Keying the memo on the joined strings makes the
+     * dependency structural rather than referential.
+     */
+    const typeKey = types ? types.join(",") : "";
+    const facetKey = facets ? facets.join(",") : "";
+    return React.useMemo(() => {
+        if (!index) {
+            return { status, result: null, suggestions: [], facets: [], builtAt: null };
+        }
+        const q = query.trim();
+        if (!q) {
+            return {
+                status,
+                result: null,
+                suggestions: [],
+                facets: [],
+                builtAt: index.builtAt,
+            };
+        }
+        const hits = searchIndex(index.artifact, index.prepared, q, {
+            limit: MATCH_LIMIT,
+            types: typeKey ? typeKey.split(",") : undefined,
+            facets: facetKey ? facetKey.split(",") : undefined,
+        });
+        /*
+         * Terms come from the SAME parser the matcher used, so a query that
+         * normalises away ("!!!") reports zero terms and the page can render its
+         * "no searchable words" state — which is a different thing from "nothing
+         * matched", and the distinction the server tier also draws via
+         * `plan.empty`.
+         */
+        const terms = parseSearchTxtQuery(q);
+        return {
+            status,
+            result: toSearchResult(q, terms, hits, {
+                label,
+                moreHref: moreHrefResolver(index.artifact),
+            }),
+            suggestions: hits.slice(0, 8).map((h) => ({
+                objectID: h.href,
+                type: suggestionTypeFor(h.typeKey),
+                typeKey: h.typeKey,
+                title: h.title,
+                subtitle: h.detail || undefined,
+                url: h.href,
+            })),
+            facets: countFacets(hits),
+            builtAt: index.builtAt,
+        };
+    }, [index, status, query, typeKey, facetKey, label]);
+}

package/dist/features/search/index.d.ts

@@ -1,7 +1,3 @@
-export * from "./types";
-export * from "./schemas";
-export * from "./columns";
-export * from "./hooks/useSearch";
 export * from "./hooks/useNavSuggestions";
 export * from "./components";
 export { manifest } from "./manifest";

package/dist/features/search/index.js

@@ -1,7 +1,3 @@
-export * from "./types/index.js";
-export * from "./schemas/index.js";
-export * from "./columns/index.js";
-export * from "./hooks/useSearch.js";
 export * from "./hooks/useNavSuggestions.js";
 export * from "./components/index.js";
 export { manifest } from "./manifest.js";

package/dist/features/search/manifest.d.ts

@@ -1,2 +1,14 @@
 import type { FeatureManifest } from "../../contracts";
+/**
+ * `default` is `SearchResultsClient`, which is what `[locale]/search/page.tsx`
+ * actually renders. It used to say `SearchView` — a component the route has
+ * never rendered, from the dead legacy `feat-search` subsystem — and A7
+ * (`audit-feature-manifest-routes`) is what this file is the fixed example
+ * for.
+ *
+ * `api/search` (the dead `SearchRepository`-backed GET handler) was removed
+ * from `apiRoutes` in the same Wave 10 commit that deleted the route itself
+ * — the manifest and the filesystem go empty together, not one claiming the
+ * other vanished a week early.
+ */
 export declare const manifest: FeatureManifest;

package/dist/features/search/manifest.js

@@ -1,10 +1,25 @@
+/**
+ * `default` is `SearchResultsClient`, which is what `[locale]/search/page.tsx`
+ * actually renders. It used to say `SearchView` — a component the route has
+ * never rendered, from the dead legacy `feat-search` subsystem — and A7
+ * (`audit-feature-manifest-routes`) is what this file is the fixed example
+ * for.
+ *
+ * `api/search` (the dead `SearchRepository`-backed GET handler) was removed
+ * from `apiRoutes` in the same Wave 10 commit that deleted the route itself
+ * — the manifest and the filesystem go empty together, not one claiming the
+ * other vanished a week early.
+ */
 export const manifest = {
     name: "search",
     i18nNamespace: "search",
     envKeys: [],
-    routes: [{ segment: "[locale]/search", exports: { default: "SearchView" } }],
+    routes: [
+        { segment: "[locale]/search", exports: { default: "SearchResultsClient" } },
+    ],
     apiRoutes: [
-        { segment: "api/search", methods: ["GET"] },
+        { segment: "api/search/scoped", methods: ["GET"] },
+        { segment: "api/search/suggestions", methods: ["GET"] },
         { segment: "api/categories/flat", methods: ["GET"] },
     ],
 };

package/dist/features/search/server.d.ts

@@ -1,4 +1 @@
-export * from "./actions";
-export { SearchRepository } from "./repository/search.repository";
 export { manifest } from "./manifest";
-export { GET as searchGET, GET } from "./api/route";

package/dist/features/search/server.js

@@ -1,4 +1 @@
-export * from "./actions/index.js";
-export { SearchRepository } from "./repository/search.repository.js";
 export { manifest } from "./manifest.js";
-export { GET as searchGET, GET } from "./api/route.js";

package/dist/features/seller/actions/offer-actions.d.ts

@@ -4,7 +4,7 @@
  * Business logic for the Make-an-Offer feature lifecycle.
  * Auth, rate-limiting, and input validation are handled by the calling server action.
  */
-import type { OfferDocument } from "../schemas";
+import type { OfferDocument, OfferPlain } from "../schemas";
 /**
  * How long an accepted offer stays claimable at its locked price. Shared by the
  * seller-accept path, the buyer-accepts-counter path, and the expiry sweep so
@@ -28,11 +28,11 @@ export interface BuyerCounterInput {
     counterAmount: number;
     buyerNote?: string;
 }
-export declare function makeOffer(userId: string, userEmail: string, input: MakeOfferInput): Promise<OfferDocument>;
+export declare function makeOffer(userId: string, userEmail: string, input: MakeOfferInput): Promise<OfferPlain>;
 export declare function respondToOffer(userId: string, input: RespondToOfferInput): Promise<OfferDocument>;
 export declare function acceptCounterOffer(userId: string, offerId: string): Promise<OfferDocument>;
-export declare function counterOfferByBuyer(userId: string, userEmail: string, input: BuyerCounterInput): Promise<OfferDocument>;
+export declare function counterOfferByBuyer(userId: string, userEmail: string, input: BuyerCounterInput): Promise<OfferPlain>;
 export declare function withdrawOffer(userId: string, offerId: string): Promise<void>;
-export declare function listBuyerOffers(userId: string): Promise<OfferDocument[]>;
-export declare function listSellerOffers(userId: string): Promise<OfferDocument[]>;
+export declare function listBuyerOffers(userId: string): Promise<OfferPlain[]>;
+export declare function listSellerOffers(userId: string): Promise<OfferPlain[]>;
 export declare function checkoutOffer(userId: string, offerId: string): Promise<CartDocument>;

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

@@ -12,7 +12,6 @@ import { sendNotification } from "../../admin/actions/notification-actions.js";
 import { userRepository } from "../../auth/repository/user.repository.js";
 import { storeRepository } from "../../stores/repository/store.repository.js";
 import { cartRepository } from "../../cart/repository/cart.repository.js";
-import { maskOfferForSeller } from "../../../security/index.js";
 import { ERROR_MESSAGES, AuthorizationError, ValidationError, NotFoundError, OFFER_ERROR_CODES, } from "../../../errors/index.js";
 import { canMakeOffer } from "../../../_internal/shared/listing-types/capabilities.js";
 import { normalizeListingType } from "../../products/utils/listing-type.js";
@@ -122,17 +121,27 @@ export async function makeOffer(userId, userEmail, input) {
     if (alreadyActive)
         throw new ValidationError(ERROR_MESSAGES.OFFER.ACTIVE_OFFER_EXISTS);
     const profile = await userRepository.findById(userId);
+    /*
+     * 🛑 REVEALED. `createOffer` encrypts `buyerEmail` (`OFFER_PII_FIELDS`), so
+     * the ciphertext this read returns would have been encrypted a second time
+     * and become permanently unreadable — the seller could never see who made
+     * the offer. The sibling `bid-actions.ts:223,481` was fixed for exactly this;
+     * this line is the same shape, missed.
+     *
+     * `userEmail` (the parameter) is already plaintext, so it needs no unwrap.
+     */
+    const profilePlain = profile ? userRepository.revealUser(profile) : null;
     const buyerDisplayName = profile?.displayName ?? "Buyer";
     if (!product.storeId)
         throw new ValidationError("Product is not associated with a store.");
-    const offer = await offerRepository.create({
+    const offer = await offerRepository.createOffer({
         productId,
         productTitle: product.title,
         productSlug: product.slug,
         productImageUrl: product.mainImage,
         buyerUid: userId,
         buyerName: buyerDisplayName,
-        buyerEmail: profile?.email ?? userEmail ?? "",
+        buyerEmail: profilePlain?.email ?? userEmail ?? "",
         storeId: product.storeId,
         storeName: product.storeName ?? "",
         offerAmount,
@@ -284,14 +293,24 @@ export async function counterOfferByBuyer(userId, userEmail, input) {
     // single-field equality served by the automatic index.
     const chainRoot = offer.chainRootOfferId ?? offer.id;
     const nextRound = (offer.counterRound ?? 1) + 1;
-    const newOffer = await offerRepository.create({
+    /*
+     * 🛑 A NINTH double-encryption site, found by the nominal brand.
+     *
+     * A buyer counter creates a NEW offer document carrying the previous round's
+     * buyer identity forward. `offer` came from a read, so those two fields are
+     * ciphertext — and `createOffer` encrypts `buyerName`/`buyerEmail` again
+     * (`OFFER_PII_FIELDS`), so round 2 onward stored a permanently unreadable
+     * buyer. Rounds 1 was fine, which is why nothing looked wrong.
+     */
+    const offerPlain = offerRepository.revealOffer(offer);
+    const newOffer = await offerRepository.createOffer({
         productId: offer.productId,
         productTitle: offer.productTitle,
         productSlug: offer.productSlug,
         productImageUrl: offer.productImageUrl,
         buyerUid: userId,
-        buyerName: offer.buyerName,
-        buyerEmail: offer.buyerEmail,
+        buyerName: offerPlain.buyerName,
+        buyerEmail: offerPlain.buyerEmail,
         storeId: offer.storeId,
         storeName: offer.storeName,
         offerAmount: counterAmount,
@@ -349,14 +368,25 @@ export async function withdrawOffer(userId, offerId) {
 // --- Read ------------------------------------------------------------------
 export async function listBuyerOffers(userId) {
     const result = await offerRepository.findByBuyer(userId);
-    return result.items;
+    /*
+     * REVEALED: these are the buyer's OWN offers, so showing them their own name
+     * and email in full is the canonical legitimate plaintext read. The seller's
+     * view of the same documents goes through `maskedOffer` instead.
+     */
+    return result.items.map((o) => offerRepository.revealOffer(o));
 }
 export async function listSellerOffers(userId) {
     const store = await storeRepository.findByOwnerId(userId);
     if (!store)
         return [];
     const result = await offerRepository.findByStore(store.id);
-    return result.items.map(maskOfferForSeller);
+    /*
+     * `maskedOffer`, not `maskOfferForSeller`. The latter calls `maskName`,
+     * which refuses ciphertext by design and answers "Anonymous" — and
+     * `findByStore` returns raw documents. So the seller's own offers list
+     * showed every buyer as Anonymous. `maskedOffer` decrypts first, then masks.
+     */
+    return result.items.map((o) => offerRepository.maskedOffer(o));
 }
 // --- Buyer: Checkout accepted offer ----------------------------------------
 export async function checkoutOffer(userId, offerId) {

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

@@ -257,7 +257,7 @@ export async function requestPayout(userId, userName, userEmail, input) {
     const earnings = await computeSellerEarnings(userId);
     if (earnings.netAmount <= 0 || earnings.eligibleOrders.length === 0)
         throw new ValidationError("No eligible earnings available for payout.");
-    const payout = await payoutRepository.create({
+    const payout = await payoutRepository.createPayout({
         storeId: userId,
         sellerName: userName,
         sellerEmail: userEmail,
@@ -288,6 +288,16 @@ export async function bulkSellerOrder(userId, userRole, userDisplayName, userEma
     const userDoc = await userRepository.findById(userId);
     if (!userDoc)
         throw new AuthorizationError("User not found");
+    /*
+     * 🛑 REVEALED before building a payout — the same active corruption the two
+     * payout crons had. `findById` is ciphertext-by-default and `createPayout`
+     * encrypts `upiId` again (`PAYOUT_PII_FIELDS`), so the seller-initiated path
+     * wrote a permanently unreadable payee address too.
+     *
+     * `payoutDetails` is encrypted by `encryptPayoutDetails`, a separate scheme
+     * from the `piiFields` path, which is why `revealUser` unwraps it explicitly.
+     */
+    const userPlain = userRepository.revealUser(userDoc);
     if (!userDoc.payoutDetails?.isConfigured) {
         throw new ValidationError("Payout details are not set up. Please configure your payout method before requesting a payout.");
     }
@@ -337,7 +347,7 @@ export async function bulkSellerOrder(userId, userRole, userDisplayName, userEma
     const grossAmount = ordersTaxableValue(eligible);
     const bulkSiteSettings = await siteSettingsRepository.getSingleton();
     const bulkDeduction = computePayoutDeduction(grossAmount, bulkSiteSettings.commissions);
-    const payoutDoc = await payoutRepository.create({
+    const payoutDoc = await payoutRepository.createPayout({
         storeId: userId,
         sellerName: userDisplayName,
         sellerEmail: userEmail,
@@ -351,14 +361,31 @@ export async function bulkSellerOrder(userId, userRole, userDisplayName, userEma
         gstAmount: bulkDeduction.gstOnFee,
         gstRate: bulkSiteSettings.commissions.gstPercent / 100,
         currency: getDefaultCurrency(),
-        paymentMethod: userDoc.payoutDetails.method === "upi"
+        paymentMethod: userPlain.payoutDetails?.method === "upi"
             ? "upi"
             : "bank_transfer",
-        upiId: userDoc.payoutDetails.method === "upi"
-            ? userDoc.payoutDetails.upiId
+        upiId: userPlain.payoutDetails?.method === "upi"
+            ? userPlain.payoutDetails.upiId
             : undefined,
-        bankAccount: userDoc.payoutDetails.method === "bank_transfer"
-            ? userDoc.payoutDetails.bankAccount
+        /*
+         * 🛑 Only the MASKED subset, matching both payout crons.
+         *
+         * This used to copy the whole `bankAccount`, including the real
+         * `accountNumber` that `encryptPayoutDetails` had encrypted on the user
+         * document. `PAYOUT_PII_FIELDS` does not list it and
+         * `encryptPayoutBankAccount` is a no-op, so the ciphertext was stored
+         * verbatim on the payout where nothing would ever unwrap it — and
+         * revealing it instead would store a real account number in the clear.
+         * A payout does not need the full number; it needs to identify the account.
+         */
+        bankAccount: userPlain.payoutDetails?.method === "bank_transfer" &&
+            userPlain.payoutDetails.bankAccount
+            ? {
+                accountHolderName: userPlain.payoutDetails.bankAccount.accountHolderName,
+                accountNumberMasked: userPlain.payoutDetails.bankAccount.accountNumberMasked,
+                ifscCode: userPlain.payoutDetails.bankAccount.ifscCode,
+                bankName: userPlain.payoutDetails.bankAccount.bankName,
+            }
             : undefined,
         notes: `Payout request for ${eligible.length} custom-shipped delivered order(s)`,
     });

package/dist/features/seller/api/coupons/route.js

@@ -37,7 +37,7 @@ export const GET = createRouteHandler({
             filters: `sellerId==${user.uid}`,
             sort,
             page,
-            perPage: pageSize,
+            pageSize: pageSize,
         });
         return NextResponse.json({
             success: true,

package/dist/features/seller/api/products/route.js

@@ -48,7 +48,7 @@ export const GET = createRouteHandler({
             filters: combinedFilters,
             sort,
             page,
-            perPage: pageSize,
+            pageSize: pageSize,
         });
         const totalPages = Math.max(1, Math.ceil(result.total / pageSize));
         // Keep same response shape as local route so useSellerProducts hook needs no changes

package/dist/features/seller/api/store/route.js

@@ -24,7 +24,7 @@ export const GET = createRouteHandler({
         const repo = db.getRepository("stores");
         const result = await repo.findAll({
             filters: `ownerId==${user.uid}`,
-            perPage: 1,
+            pageSize: 1,
         });
         return NextResponse.json({
             success: true,

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

@@ -106,7 +106,7 @@ export function SellerBidsView({ endpoint = SELLER_ENDPOINTS.BIDS }) {
         sortOptions: SORT_OPTIONS,
         initialView: "list",
         columns,
-        mapRows: (response) => toRecordArray(response.bids).map((item, idx) => ({
+        mapRows: (response) => toRecordArray(response.items).map((item, idx) => ({
             id: toStringValue(item.id, `bid-${idx}`),
             productTitle: toStringValue(item.productTitle, "Unknown auction"),
             productId: toStringValue(item.productId, ""),

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

@@ -68,7 +68,7 @@ export function SellerCouponsView({ onCreateClick, onEditClick, onToggle, onDele
             { value: "code", label: "Code A–Z" },
         ],
         hideTableView: true,
-        mapRows: (response) => toRecordArray(response.coupons).map((item, index) => ({
+        mapRows: (response) => toRecordArray(response.items).map((item, index) => ({
             id: toStringValue(item.id, `coupon-${index}`),
             raw: item,
             isActive: getIsActive(item),

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

@@ -53,7 +53,7 @@ export interface SellerListingTypeSpec {
  * because standard / auction / pre-order / prize-draw do NOT have one — their
  * store routes redirect into the multi-type `SellerProductsView`.
  */
-export type SellerListingTypeKey = "art" | "stickers" | "classified" | "digital-code" | "live";
+export type SellerListingTypeKey = "art" | "stickers" | "classified" | "digital-code" | "live" | "spares";
 export declare const SELLER_LISTING_TYPE_SPECS: Record<SellerListingTypeKey, SellerListingTypeSpec>;
 export interface SellerListingTypeViewProps {
     onCreateClick?: () => void;

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

@@ -87,6 +87,26 @@ export const SELLER_LISTING_TYPE_SPECS = {
         }),
         extraColumns: [textCell("size", "Size")],
     },
+    spares: {
+        editRoute: (id) => String(ROUTES.STORE.SPARES_EDIT(id)),
+        newRoute: String(ROUTES.STORE.SPARES_NEW),
+        createLabel: "List a Spare",
+        bulkKey: "spares",
+        deleteLabel: "Spare Listing",
+        searchPlaceholder: "Search spares by part or colour...",
+        emptyLabel: "No spares listed yet — list a part you have going spare",
+        /*
+         * Colourway, not size. Two listings of the same part code are told apart by
+         * COLOUR here — a red Cross Dranzer and a navy one are different objects to
+         * a buyer rebuilding a specific top, which is the user's own framing
+         * ("sell it to someone who wants it in the same colour"). `printMeta.size`
+         * is meaningless on a moulded component.
+         */
+        extraFields: (item) => ({
+            colourway: toStringValue(item.colourway, ""),
+        }),
+        extraColumns: [textCell("colourway", "Colourway")],
+    },
     classified: {
         editRoute: (id) => String(ROUTES.STORE.CLASSIFIED_EDIT(id)),
         newRoute: String(ROUTES.STORE.CLASSIFIED_NEW),
@@ -230,7 +250,15 @@ export function SellerListingTypeView({ type, onCreateClick, onEditClick, onDele
         // four options where its four siblings offered five.
         sortOptions: [...plugin.sortOptions],
         columns,
-        mapRows: (response) => toRecordArray(response.products ?? response.items).map((item, index) => ({
+        mapRows: (response) => 
+        /*
+         * `items` only. The `?? response.products` fallback is gone because both
+         * endpoints this config reads (`/api/admin/products`, `/api/store/products`)
+         * now emit the canonical key — verified before removing it. A defence
+         * against a shape that no longer exists reads as though the shape still
+         * might, which is how two spellings stay alive forever.
+         */
+        toRecordArray(response.items).map((item, index) => ({
             id: toStringValue(item.id, `${type}-${index}`),
             title: toStringValue(item.productTitle ?? item.title, "Untitled"),
             price: toCurrency(item.price),

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

@@ -398,7 +398,7 @@ export function SellerOrdersView({ orderDetailApiBase = SELLER_ENDPOINTS.ORDERS,
         endpoint: SELLER_ENDPOINTS.ORDERS,
         sortOptions: SORT_OPTIONS,
         columns,
-        mapRows: (response) => toRecordArray(response.orders).map((item, index) => {
+        mapRows: (response) => toRecordArray(response.items).map((item, index) => {
             const itemsArr = Array.isArray(item.items) ? item.items : [];
             /*
              * Same legacy fallback as AdminOrdersView: `items[]` is canonical and

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

@@ -46,9 +46,17 @@ const payoutSettingsDraftSchema = z.object({
     ifscCode: annotate(z.string(), { section: "method", quick: true, order: 5, row: "pair" }),
     bankName: annotate(z.string(), { section: "method", quick: true, order: 6, row: "pair" }),
     accountType: annotate(z.enum(["savings", "current"]), { section: "method", quick: true, order: 7, row: "pair" }),
+    // The three fields that identify the SUPPLIER OF RECORD on this store's
+    // invoices. A seller with a GSTIN invoices under it; one without
+    // invoices under LetItRip's (resolveSupplierIdentity).
+    //
+    // `pan` and `businessType` were removed 2026-10-19: neither exists on
+    // StoreDocument or UserDocument and the route stripped them, so a
+    // seller who entered a PAN was told it saved and it went nowhere.
+    // An input that provably cannot persist is worse than no input.
     gstin: annotate(z.string(), { section: "tax", sectionLabel: "Tax Info", order: 1, row: "pair" }),
-    pan: annotate(z.string(), { section: "tax", order: 2, row: "pair" }),
-    businessType: annotate(z.string(), { section: "tax", order: 3, row: "pair" }),
+    legalName: annotate(z.string(), { section: "tax", order: 2, row: "pair" }),
+    registeredAddress: annotate(z.string(), { section: "tax", order: 3, row: "full" }),
     autoPayout: annotate(z.boolean(), {
         section: "preferences", sectionLabel: "Preferences", order: 1, row: "quarter",
     }),
@@ -110,8 +118,8 @@ const DEFAULT_DRAFT = {
     bankName: "",
     accountType: "savings",
     gstin: "",
-    pan: "",
-    businessType: "",
+    legalName: "",
+    registeredAddress: "",
     autoPayout: true,
     minimumThreshold: "",
     emiEnabled: false,
@@ -142,9 +150,22 @@ export function SellerPayoutSettingsView({ apiBase = SELLER_ENDPOINTS.PAYOUT_SET
                 ifscCode: details.bankAccount?.ifscCode ?? "",
                 bankName: details.bankAccount?.bankName ?? "",
                 accountType: details.bankAccount?.accountType ?? "savings",
-                gstin: res?.data?.taxInfo?.gstin ?? "",
-                pan: res?.data?.taxInfo?.pan ?? "",
-                businessType: res?.data?.taxInfo?.businessType ?? "",
+                /*
+                 * 🛑 Flat fields, NOT `res.data.taxInfo.*`.
+                 *
+                 * `taxInfo` is a key the route has never returned, so these three
+                 * inputs were ALWAYS blank on load no matter what had been saved —
+                 * and the save side posted a `taxInfo` object that the route's
+                 * `z.object()` schema silently stripped. A seller could type their
+                 * GSTIN, get a success toast, reload, and find it gone.
+                 *
+                 * The route now declares and persists `gstin` / `legalName` /
+                 * `registeredAddress` on the STORE, because the GSTIN decides who
+                 * is the supplier of record on that store's invoices.
+                 */
+                gstin: res?.data?.gstin ?? "",
+                legalName: res?.data?.legalName ?? "",
+                registeredAddress: res?.data?.registeredAddress ?? "",
                 autoPayout: res?.data?.preferences?.autoPayout ?? true,
                 minimumThreshold: res?.data?.preferences?.minimumThreshold
                     ? String(res.data.preferences.minimumThreshold)
@@ -184,11 +205,11 @@ export function SellerPayoutSettingsView({ apiBase = SELLER_ENDPOINTS.PAYOUT_SET
                 pricesIncludeGst: draft.pricesIncludeGst,
                 supportsShippingProtection: draft.supportsShippingProtection,
                 supportsSaleProtection: draft.supportsSaleProtection,
-                taxInfo: {
-                    gstin: draft.gstin.trim(),
-                    pan: draft.pan.trim(),
-                    businessType: draft.businessType.trim(),
-                },
+                // Flat, matching the route's schema. A nested `taxInfo` object was
+                // stripped by `z.object()` and never reached Firestore.
+                gstin: draft.gstin.trim(),
+                legalName: draft.legalName.trim(),
+                registeredAddress: draft.registeredAddress.trim(),
                 preferences: {
                     autoPayout: draft.autoPayout,
                     minimumThreshold: Math.round(parseFloat(draft.minimumThreshold || "0") * 100) / 100,
@@ -244,8 +265,8 @@ export function SellerPayoutSettingsView({ apiBase = SELLER_ENDPOINTS.PAYOUT_SET
         {
             id: "tax",
             label: "Tax Info",
-            fields: ["gstin", "pan", "businessType"],
-            render: ({ values, onChange }) => (_jsxs(Stack, { gap: "md", children: [_jsx(Heading, { level: 3, className: "mb-2", children: "Tax Information" }), _jsx(Text, { className: "text-[var(--appkit-color-text-muted)]", size: "sm", children: "Optional \u2014 required only for GST invoice generation and TDS compliance." }), _jsx(FormField, { name: "gstin", label: "GSTIN (optional)", type: "text", value: values.gstin, onChange: (v) => onChange({ gstin: v.toUpperCase() }), placeholder: "e.g. 22AAAAA0000A1Z5", helpText: "15-character Goods and Services Tax Identification Number.", disabled: busy }), _jsx(FormField, { name: "pan", label: "PAN (optional)", type: "text", value: values.pan, onChange: (v) => onChange({ pan: v.toUpperCase() }), placeholder: "e.g. ABCDE1234F", helpText: "Required for payouts above \u20B950,000 per year (TDS threshold).", disabled: busy }), _jsx(FormField, { name: "businessType", label: "Business Type (optional)", type: "text", value: values.businessType, onChange: (v) => onChange({ businessType: v }), placeholder: "e.g. Individual, Sole Proprietor, Private Limited", disabled: busy })] })),
+            fields: ["gstin", "legalName", "registeredAddress"],
+            render: ({ values, onChange }) => (_jsxs(Stack, { gap: "md", children: [_jsx(Heading, { level: 3, className: "mb-2", children: "Tax Information" }), _jsx(Text, { className: "text-[var(--appkit-color-text-muted)]", size: "sm", children: "Optional. Enter a GSTIN and your orders are invoiced under your own registration; leave it blank and they are invoiced under LetItRip's." }), _jsx(FormField, { name: "gstin", label: "GSTIN (optional)", type: "text", value: values.gstin, onChange: (v) => onChange({ gstin: v.toUpperCase() }), placeholder: "e.g. 22AAAAA0000A1Z5", helpText: "15-character Goods and Services Tax Identification Number.", disabled: busy }), _jsx(FormField, { name: "legalName", label: "Registered legal name (optional)", type: "text", value: values.legalName, onChange: (v) => onChange({ legalName: v }), placeholder: "e.g. Arena Collectibles Pvt Ltd", helpText: "The entity name that appears on the invoice. Leave blank to use your store name.", disabled: busy }), _jsx(FormField, { name: "registeredAddress", label: "Registered address (optional)", type: "text", value: values.registeredAddress, onChange: (v) => onChange({ registeredAddress: v }), placeholder: "Address as registered against your GSTIN", helpText: "Printed on invoices issued under your GSTIN.", disabled: busy })] })),
         },
         {
             id: "preferences",
@@ -258,7 +279,6 @@ export function SellerPayoutSettingsView({ apiBase = SELLER_ENDPOINTS.PAYOUT_SET
     const { shellCtx, setFieldError, clearErrors, validate } = useFormShellState(payoutSettingsDraftSchema, { sections: sectionMeta, onGoToSection: goToSection, fieldToSectionIndex });
     useEffect(() => {
         validate(draft);
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [draft, validate]);
     return (_jsx(StackedViewShell, { portal: "seller", title: "Payout Settings", sections: [
             _jsxs(Div, { children: [error && _jsx(Alert, { variant: "error", className: "mb-4", children: error }), success && _jsx(Alert, { variant: "success", className: "mb-4", children: "Payout details saved." }), _jsxs(FormShellContext.Provider, { value: shellCtx, children: [_jsx(FormErrorSummary, {}), _jsx(SectionForm, { sections: sections, values: draft, onChange: update, onSubmit: handleSave, schema: payoutSettingsDraftSchema, openIds: openIds, onOpenChange: setOpenIds, submitLabel: "Save Payout Details", isLoading: busy })] })] }, "payout"),

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

@@ -105,7 +105,7 @@ export function SellerPayoutsView({ children, ...props }) {
             { value: sortBy("createdAt", "DESC"), label: "Newest" },
             { value: sortBy("createdAt", "ASC"), label: "Oldest" },
         ],
-        mapRows: (response) => toRecordArray(response.payouts).map((item, index) => {
+        mapRows: (response) => toRecordArray(response.items).map((item, index) => {
             const id = toStringValue(item.id, `payout-${index}`);
             rawByIdRef.current[id] = item;
             return {