@mohasinac/appkit 4.53.0 → 4.53.2

package/dist/_internal/shared/listing-types/pre-order/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    canJoinProductGroup: boolean;
     iconKey: "preOrder";
     hideDefault: "closed";
     isAvailable: (row: AvailabilityRow) => boolean;

package/dist/_internal/shared/listing-types/pre-order/config.js

@@ -21,6 +21,8 @@ export const config = {
     browseRoute: String(ROUTES.PUBLIC.PRE_ORDERS),
     // /pre-orders is in MAIN_NAV_ITEMS.
     inGeneralCatalogue: false,
+    // a deposit against a future release; members would ship at different times
+    canJoinProductGroup: false,
     iconKey: "preOrder",
     hideDefault: "closed",
     // A pre-order closes when its allocation fills, NOT when its delivery date

package/dist/_internal/shared/listing-types/prize-draw/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    canJoinProductGroup: boolean;
     iconKey: "prizeDraw";
     hideDefault: "closed";
     isAvailable: (row: AvailabilityRow) => boolean;

package/dist/_internal/shared/listing-types/prize-draw/config.js

@@ -21,6 +21,8 @@ export const config = {
     // /prize-draws is in MAIN_NAV_ITEMS. Entry-based pricing reads wrong beside
     // ordinary unit prices in the general grid.
     inGeneralCatalogue: false,
+    // sells ENTRIES at a fixed price; a group line would blur what was entered
+    canJoinProductGroup: false,
     iconKey: "prizeDraw",
     hideDefault: "closed",
     // `prizeRevealStatus`, NOT remaining entries: a draw can close with slots

package/dist/_internal/shared/listing-types/spares/config.d.ts

@@ -0,0 +1,74 @@
+import { alwaysAvailable } from "../availability";
+export declare const LISTING_TYPE: "spares";
+export declare const capability: import("../capabilities").ListingTypeCapability;
+export declare const config: {
+    listingType: "spares";
+    slugPrefix: string;
+    cartLine: "single-product";
+    detailRoute: (idOrSlug: string) => string;
+    badge: {
+        label: string;
+        className: string;
+    };
+    priceLabel: string;
+    typeLabel: string;
+    showsStockQuantity: boolean;
+    tabSlug: string;
+    pluralLabel: string;
+    chipLabel: string;
+    browseRoute: string;
+    inGeneralCatalogue: boolean;
+    canJoinProductGroup: boolean;
+    iconKey: "spares";
+    hideDefault: "sold";
+    isAvailable: typeof alwaysAvailable;
+    unavailableClauses: readonly import("../availability").UnavailableClause[];
+    sortOptions: readonly [{
+        readonly value: string;
+        readonly label: "Newest First";
+    }, {
+        readonly value: string;
+        readonly label: "Oldest First";
+    }, {
+        readonly value: string;
+        readonly label: "Price: Low to High";
+    }, {
+        readonly value: string;
+        readonly label: "Price: High to Low";
+    }, {
+        readonly value: string;
+        readonly label: "Name: A–Z";
+    }, {
+        readonly value: string;
+        readonly label: "Name: Z–A";
+    }, {
+        readonly value: string;
+        readonly label: "Featured First";
+    }, {
+        readonly value: string;
+        readonly label: "Promoted First";
+    }, {
+        readonly value: string;
+        readonly label: "Recently Updated";
+    }];
+    publicSortOptions: readonly [{
+        readonly value: string;
+        readonly label: "Newest First";
+    }, {
+        readonly value: string;
+        readonly label: "Oldest First";
+    }, {
+        readonly value: string;
+        readonly label: "Price: Low to High";
+    }, {
+        readonly value: string;
+        readonly label: "Price: High to Low";
+    }, {
+        readonly value: string;
+        readonly label: "Name: A–Z";
+    }, {
+        readonly value: string;
+        readonly label: "Name: Z–A";
+    }];
+    extraFacetKeys: readonly string[];
+};

package/dist/_internal/shared/listing-types/spares/config.js

@@ -0,0 +1,60 @@
+import { LISTING_TYPE_CAPABILITIES } from "../capabilities.js";
+import { alwaysAvailable, STOCK_ONLY_UNAVAILABLE_CLAUSES, } from "../availability.js";
+import { ROUTES } from "../../../../next/routing/route-map.js";
+import { STANDARD_SORT_OPTIONS, STANDARD_PUBLIC_SORT_OPTIONS, } from "../../../../features/products/constants/sieve.js";
+export const LISTING_TYPE = "spares";
+export const capability = LISTING_TYPE_CAPABILITIES.spares;
+export const config = {
+    listingType: LISTING_TYPE,
+    /*
+     * Singular, matching `sticker-` rather than the plural type name.
+     *
+     * 🛑 Matched by `startsWith`, so this exact string must open every seeded id
+     * or `audit-seed-listing-type`'s R3 fails on every row — that audit calls the
+     * shipped `detectListingTypeFromSlug` rather than re-deriving the map, which
+     * is how it caught five `stickers-` ids against a registered `sticker-`.
+     */
+    slugPrefix: "spare-",
+    cartLine: "single-product",
+    detailRoute: (idOrSlug) => String(ROUTES.PUBLIC.PRODUCT_DETAIL(idOrSlug)),
+    badge: { label: "Spare Part", className: "bg-primary-700 text-white" },
+    priceLabel: "Price (₹)",
+    typeLabel: "Spares",
+    showsStockQuantity: true,
+    tabSlug: "spares",
+    pluralLabel: "Spares",
+    chipLabel: "Spares",
+    browseRoute: String(ROUTES.PUBLIC.SPARES),
+    /*
+     * 🛑 `false`, and it obliges the nav entry that lands in the same change.
+     *
+     * The rule for this flag is nav reachability, not taste: a type kept out of
+     * the general catalogue must own a page that `MAIN_NAV_ITEMS` links, or it is
+     * reachable from nowhere (Root Cause #61). `/spares` is that page.
+     *
+     * The reason to keep it out is the catalogue itself. A seller who strips one
+     * Beyblade lists eight parts, so a few disassembled items would outnumber
+     * every complete listing on `/products` — and a buyer looking for a loose
+     * attack ring wants a page where everything is a loose part, not one where
+     * they are scattered among bundles and sealed boxes.
+     */
+    inGeneralCatalogue: false,
+    /*
+     * A sheet-plus-parts group is the shape this exists for on the sticker side,
+     * and the same shape sells a stripped bey: the whole item as the parent, each
+     * salvaged part as a child, buyer takes any mix.
+     */
+    canJoinProductGroup: true,
+    iconKey: "spares",
+    hideDefault: "sold",
+    /*
+     * A spare runs out rather than ending — there is no time dimension at all, so
+     * the shared stock-only rules are the whole story. Usually quantity 1: it is
+     * one physical object the seller happens to have.
+     */
+    isAvailable: alwaysAvailable,
+    unavailableClauses: STOCK_ONLY_UNAVAILABLE_CLAUSES,
+    sortOptions: STANDARD_SORT_OPTIONS,
+    publicSortOptions: STANDARD_PUBLIC_SORT_OPTIONS,
+    extraFacetKeys: [],
+};

package/dist/_internal/shared/listing-types/spares/ctas.d.ts

@@ -0,0 +1 @@
+export declare const ctas: readonly string[];

package/dist/_internal/shared/listing-types/spares/ctas.js

@@ -0,0 +1,4 @@
+// Spares reuse the standard "Add to Cart" / "Buy Now" CTAs — plus the shared
+// Make-an-Offer control, which is driven by `capability.canMakeOffer` rather
+// than by anything here (mirrors the art/stickers/live placeholders).
+export const ctas = [];

package/dist/_internal/shared/listing-types/spares/og.js

@@ -0,0 +1 @@
+export {};

package/dist/_internal/shared/listing-types/spares/schema.d.ts

@@ -0,0 +1,2 @@
+import type { ProductDocument } from "../../../../features/products/schemas/firestore";
+export declare function isSparesProduct(doc: ProductDocument): boolean;

package/dist/_internal/shared/listing-types/spares/schema.js

@@ -0,0 +1,3 @@
+export function isSparesProduct(doc) {
+    return doc.listingType === "spares";
+}

package/dist/_internal/shared/listing-types/spares/seed-factory.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/_internal/shared/listing-types/spares/seed-factory.js

@@ -0,0 +1 @@
+export {};

package/dist/_internal/shared/listing-types/standard/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    canJoinProductGroup: boolean;
     iconKey: "order";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;

package/dist/_internal/shared/listing-types/standard/config.js

@@ -19,6 +19,8 @@ export const config = {
     browseRoute: String(ROUTES.PUBLIC.PRODUCTS),
     // The general catalogue IS this type's page.
     inGeneralCatalogue: true,
+    // the ordinary case — a complete item whose parts can be sold beside it
+    canJoinProductGroup: true,
     iconKey: "order",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared

package/dist/_internal/shared/listing-types/stickers/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    canJoinProductGroup: boolean;
     iconKey: "stickers";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;

package/dist/_internal/shared/listing-types/stickers/config.js

@@ -22,6 +22,8 @@ export const config = {
     browseRoute: String(ROUTES.PUBLIC.ART),
     // /art ("Art & Stickers") is in MAIN_NAV_ITEMS and spans art + stickers.
     inGeneralCatalogue: false,
+    // THE case this exists for: a sheet plus its individual cut-out stickers
+    canJoinProductGroup: true,
     iconKey: "stickers",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared

package/dist/_internal/shared/search/match.d.ts

@@ -7,6 +7,17 @@ export interface ResolvedEntity {
     readonly detail: string;
     readonly href: string;
     readonly score: number;
+    /**
+     * The record's raw compact facet string (`"lt:auction|br:takara-tomy"`), or
+     * `""`. Carried on the hit so a facet rail can count what the CURRENT result
+     * set contains without going back to the artifact and re-finding each row.
+     *
+     * 🛑 Raw rather than parsed, on purpose. Parsing is `facetsOf(rec)` and it
+     * allocates an array per record; a rail counts over every hit on every
+     * keystroke, and most queries never render one. The consumer parses the
+     * handful it actually needs.
+     */
+    readonly facets: string;
 }
 export interface ResolveOptions {
     readonly limit?: number;

package/dist/_internal/shared/search/match.js

@@ -57,7 +57,7 @@
 import { normalizeSearchText, parseSearchTxtQuery } from "../../../utils/search-txt.js";
 import { aliasVariantsForName } from "./alias-variants.js";
 import { partAliasTokens } from "./part-aliases.js";
-import { facetsOf, hrefFor, REC_DETAIL, REC_TITLE, REC_TYPE, } from "./index-record.js";
+import { facetsOf, hrefFor, REC_DETAIL, REC_FACETS, REC_TITLE, REC_TYPE, } from "./index-record.js";
 /** Field weights. Title dominates; a detail match is corroboration. */
 const W_TITLE = 3;
 const W_DETAIL = 1;
@@ -119,6 +119,30 @@ export function prepareIndex(artifact) {
         };
     });
 }
+/**
+ * The shortest term allowed to match MID-WORD.
+ *
+ * 🛑 This exists because of a reported bug, and the mechanism is worth stating:
+ * the substring tier is `flat.includes(term)`, and for a one-character term
+ * that is satisfied by almost every record in the artifact. A category's
+ * `detail` is its " › "-joined path, so `"g"` matches
+ * `"Spinning Tops › Beyblade Original › Dragoon Line"` on the `g` in
+ * "Spinning". AND semantics then cannot narrow anything: `"dragoon g"` scored
+ * identically to `"dragoon"` and returned every Dragoon in the catalogue —
+ * which is the "even if I type dragoon g the results show everything"
+ * complaint, and it was never the AND logic's fault.
+ *
+ * 🛑 It does NOT reintroduce a minimum query length. This module's header is
+ * explicit that typing `"d"` and seeing something is what a local index is FOR,
+ * and it still does: the EXACT and PREFIX tiers are untouched, so a
+ * one-character term still matches any word starting with it. Only the mid-word
+ * tier is gated, because one character appearing somewhere inside a string is
+ * not evidence of intent.
+ *
+ * Two rather than three: `"cx"`, `"bu"`, `"gt"` and `"1b"` are real product
+ * vocabulary a collector types, and they discriminate.
+ */
+const MIN_SUBSTRING_TERM = 2;
 /** Best match quality for one term against one field. 0 means no match. */
 function fieldScore(term, words, flat) {
     if (!flat)
@@ -129,8 +153,10 @@ function fieldScore(term, words, flat) {
     for (const w of words)
         if (w.startsWith(term))
             return S_PREFIX;
-    // Mid-word. The capability the token index cannot have.
-    if (flat.includes(term))
+    // Mid-word. The capability the token index cannot have — but see
+    // MIN_SUBSTRING_TERM: for a single character it is not a capability, it is a
+    // match against everything.
+    if (term.length >= MIN_SUBSTRING_TERM && flat.includes(term))
         return S_SUBSTRING;
     return 0;
 }
@@ -198,6 +224,7 @@ export function searchIndex(artifact, prepared, query, opts = {}) {
                 title: p.rec[REC_TITLE],
                 detail: p.rec[REC_DETAIL],
                 href: hrefFor(artifact, p.rec),
+                facets: p.rec[REC_FACETS] ?? "",
                 // An alias hit is a weaker signal than a direct one and must not
                 // outrank it when both are present in a later, wider query.
                 score: aliasPass ? score - S_ALIAS : score,

package/dist/_internal/shared/search/to-groups.d.ts

@@ -0,0 +1,52 @@
+import type { SearchEverythingResult, SearchGroup } from "../../server/features/search/search-everything";
+import type { ResolvedEntity } from "./match";
+import type { SearchIndexArtifact } from "./index-record";
+/** Rows shown per group before "see all". Matches the server tier's PER_GROUP. */
+export declare const LOCAL_PER_GROUP = 6;
+export interface ToGroupsOptions {
+    readonly perGroup?: number;
+    /**
+     * `typeKey` -> human heading. REQUIRED, and the artifact deliberately does
+     * not carry it: a label baked into a shared immutable artifact cannot be
+     * translated, and this app is `[locale]`-routed. The caller resolves it
+     * through the label system at render time.
+     */
+    readonly label: (typeKey: string) => string;
+    /** `typeKey` -> the type's browse page, from the artifact's type table. */
+    readonly moreHref: (typeKey: string) => string;
+}
+/**
+ * Group score-ordered hits by type, preserving the order the types first
+ * appear in.
+ *
+ * 🛑 Group ORDER follows the best hit in each group, not the type table's
+ * `weight`. Weight already biased the scores; applying it again as an
+ * ordering key would double-count it, and a query that matched one FAQ
+ * exactly would still rank a weak product match above it.
+ */
+export declare function toSearchGroups(hits: readonly ResolvedEntity[], opts: ToGroupsOptions): SearchGroup[];
+/** Assemble the full result envelope the page component expects. */
+export declare function toSearchResult(q: string, terms: readonly string[], hits: readonly ResolvedEntity[], opts: ToGroupsOptions): SearchEverythingResult;
+export interface FacetCount {
+    readonly key: string;
+    readonly value: string;
+    readonly count: number;
+}
+/**
+ * Count facet values across a result set.
+ *
+ * ## 🛑 This is the thing the server tier structurally cannot afford
+ *
+ * `BaseRepository.facetCounts` runs ONE aggregation query per facet value,
+ * each needing its own composite index, and on a missing index it logs and
+ * returns `undefined` so the facet "stays visible" with no count. Here it is
+ * a `reduce` over an array already in memory: zero queries, zero indexes, and
+ * a count that cannot silently fail.
+ *
+ * Counts are over the hits the CURRENT query produced, so ticking one facet
+ * and watching the others shrink is truthful rather than an approximation of
+ * the whole catalogue.
+ */
+export declare function countFacets(hits: readonly ResolvedEntity[]): FacetCount[];
+/** Look up a type's `moreHref` from the artifact's own table. */
+export declare function moreHrefResolver(artifact: Pick<SearchIndexArtifact, "types">): (typeKey: string) => string;

package/dist/_internal/shared/search/to-groups.js

@@ -0,0 +1,141 @@
+/*
+ * WHY: Tier 1 and Tier 2 must render through the SAME component, or the page
+ *      grows two layouts that drift.
+ * WHAT: `ResolvedEntity[]` (browser matcher) -> `SearchGroup[]` (the shape
+ *       `SearchResultsPageView` already renders), plus facet counting.
+ *
+ * ## 🛑 Written against the server's types, not beside them
+ *
+ * `SearchGroup` / `SearchHit` / `SearchEverythingResult` are declared in
+ * `_internal/server/features/search/search-everything.ts` and imported here
+ * as TYPES ONLY — erased at runtime, so nothing of the server reaches a
+ * browser bundle. `SearchResultsPageView` already does exactly this, so the
+ * boundary is established rather than invented here.
+ *
+ * Defining a parallel `LocalSearchGroup` would have been the easy call and
+ * the wrong one: two near-identical result shapes is how a page ends up with
+ * two renderers, and then a fix to one of them (Root Cause #59's shape).
+ *
+ * ## 🛑 `truncated` is FALSE here, and that is a real difference
+ *
+ * The server tier reads a bounded window per collection, so a saturated fetch
+ * makes its count a FLOOR and it must render "6+". Tier 1 holds the entire
+ * corpus in memory, so the count is EXACT — there is no window to saturate.
+ * Reporting `truncated: true` because a group was capped for DISPLAY would be
+ * a different claim ("there may be more we could not see") and a false one.
+ * `total` carries the real figure; `hits` is the slice shown.
+ *
+ * @tag domain:search
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:useSiteSearch,SearchResultsClient
+ * @tag sideEffects:none
+ */
+/** Rows shown per group before "see all". Matches the server tier's PER_GROUP. */
+export const LOCAL_PER_GROUP = 6;
+/**
+ * Group score-ordered hits by type, preserving the order the types first
+ * appear in.
+ *
+ * 🛑 Group ORDER follows the best hit in each group, not the type table's
+ * `weight`. Weight already biased the scores; applying it again as an
+ * ordering key would double-count it, and a query that matched one FAQ
+ * exactly would still rank a weak product match above it.
+ */
+export function toSearchGroups(hits, opts) {
+    const perGroup = opts.perGroup ?? LOCAL_PER_GROUP;
+    const order = [];
+    const byType = new Map();
+    for (const hit of hits) {
+        let bucket = byType.get(hit.typeKey);
+        if (!bucket) {
+            bucket = [];
+            byType.set(hit.typeKey, bucket);
+            order.push(hit.typeKey);
+        }
+        bucket.push(hit);
+    }
+    return order.map((typeKey) => {
+        const bucket = byType.get(typeKey) ?? [];
+        const groupHits = bucket.slice(0, perGroup).map((h) => ({
+            /*
+             * The href IS the identity here. The artifact has no document id — it
+             * carries a slug, and two types can share a destination (a model
+             * composition and its category leaf both render `/categories/{s}`),
+             * which the matcher already dedupes on. Using the same key keeps the
+             * two consistent; inventing `${typeKey}:${slug}` would give the same
+             * row two identities depending on which layer you asked.
+             */
+            id: h.href,
+            title: h.title,
+            href: h.href,
+            detail: h.detail || undefined,
+        }));
+        return {
+            key: typeKey,
+            label: opts.label(typeKey),
+            hits: groupHits,
+            truncated: false, // see the header — the count is exact, not a floor
+            moreHref: opts.moreHref(typeKey),
+        };
+    });
+}
+/** Assemble the full result envelope the page component expects. */
+export function toSearchResult(q, terms, hits, opts) {
+    const groups = toSearchGroups(hits, opts);
+    return {
+        q,
+        terms: [...terms],
+        groups,
+        /*
+         * The TOTAL matched, not the total shown. A page that says "24 results"
+         * and renders 12 because each group capped at 6 is lying in the direction
+         * that matters least; one that says "12" when 24 matched hides half the
+         * corpus from someone deciding whether to refine.
+         */
+        totalHits: hits.length,
+    };
+}
+/**
+ * Count facet values across a result set.
+ *
+ * ## 🛑 This is the thing the server tier structurally cannot afford
+ *
+ * `BaseRepository.facetCounts` runs ONE aggregation query per facet value,
+ * each needing its own composite index, and on a missing index it logs and
+ * returns `undefined` so the facet "stays visible" with no count. Here it is
+ * a `reduce` over an array already in memory: zero queries, zero indexes, and
+ * a count that cannot silently fail.
+ *
+ * Counts are over the hits the CURRENT query produced, so ticking one facet
+ * and watching the others shrink is truthful rather than an approximation of
+ * the whole catalogue.
+ */
+export function countFacets(hits) {
+    const tally = new Map();
+    for (const hit of hits) {
+        if (!hit.facets)
+            continue;
+        for (const pair of hit.facets.split("|")) {
+            // Guard the shape rather than trusting it: a malformed pair is one
+            // record's problem, not a reason to drop the whole rail.
+            if (pair.indexOf(":") > 0)
+                tally.set(pair, (tally.get(pair) ?? 0) + 1);
+        }
+    }
+    const out = [];
+    for (const [pair, count] of tally) {
+        const i = pair.indexOf(":");
+        out.push({ key: pair.slice(0, i), value: pair.slice(i + 1), count });
+    }
+    // Commonest first within a key, then alphabetical — a rail ordered by raw
+    // string would bury the useful refinement below the rare ones.
+    out.sort((a, b) => a.key.localeCompare(b.key) || b.count - a.count || a.value.localeCompare(b.value));
+    return out;
+}
+/** Look up a type's `moreHref` from the artifact's own table. */
+export function moreHrefResolver(artifact) {
+    const map = new Map(artifact.types.map((t) => [t.key, t.moreHref]));
+    return (typeKey) => map.get(typeKey) ?? "/";
+}

package/dist/client.d.ts

@@ -292,9 +292,11 @@ export { StoreSidebar } from "./features/seller/components/SellerSidebar";
 export type { StoreNavItem, StoreNavGroup } from "./features/seller/components/SellerSidebar";
 export { StoreProductsView, StoreAboutView } from "./features/stores/index";
 export type { StoreProductItem, StoreAboutViewProps, StoreDetail } from "./features/stores/index";
-export { SearchView } from "./features/search/index";
-export type { SearchViewProps } from "./features/search/index";
 export { useSearchIndex, ensureSearchIndex } from "./features/search/hooks/useSearchIndex";
+export { useSiteSearch } from "./features/search/hooks/useSiteSearch";
+export { useScopedSearch, mergeSearchTiers } from "./features/search/hooks/useScopedSearch";
+export type { UseScopedSearchResult } from "./features/search/hooks/useScopedSearch";
+export type { UseSiteSearchOptions, UseSiteSearchResult } from "./features/search/hooks/useSiteSearch";
 export type { SearchIndexState, SearchIndexStatus, LoadedSearchIndex, UseSearchIndexOptions, } from "./features/search/hooks/useSearchIndex";
 export { AdSlot } from "./features/homepage/components/AdSlot";
 export { useActiveAd } from "./features/homepage/hooks/useActiveAd";
@@ -456,6 +458,8 @@ export { SellerArtView } from "./features/seller/components/SellerArtView";
 export type { SellerArtViewProps } from "./features/seller/components/SellerArtView";
 export { SellerStickersView } from "./features/seller/components/SellerStickersView";
 export type { SellerStickersViewProps } from "./features/seller/components/SellerStickersView";
+export { SellerSparesView } from "./features/seller/components/SellerSparesView";
+export type { SellerSparesViewProps } from "./features/seller/components/SellerSparesView";
 export { SellerDigitalCodesView } from "./features/seller/components/SellerDigitalCodesView";
 export type { SellerDigitalCodesViewProps } from "./features/seller/components/SellerDigitalCodesView";
 export { SellerLiveView } from "./features/seller/components/SellerLiveView";
@@ -501,6 +505,8 @@ export type { FAQCategory, FAQCategoryItem, FAQSortOption } from "./features/faq
 export { CategoryInlineSelect } from "./features/seller/components/CategoryInlineSelect";
 export { CategoryTemplatePicker, variantForCondition } from "./features/categories/components/CategoryTemplatePicker";
 export type { CategoryTemplatePickerProps, CategoryTemplateApply } from "./features/categories/components/CategoryTemplatePicker";
+export { PriceGuidanceHint } from "./features/categories/components/PriceGuidanceHint";
+export type { PriceGuidanceHintProps } from "./features/categories/components/PriceGuidanceHint";
 export { BrandInlineSelect } from "./features/seller/components/BrandInlineSelect";
 export { API_ENDPOINTS } from "./constants/index";
 export { SELLER_LISTING_TABS, type SellerListingTabId, } from "./features/products/constants/listing-tabs";

package/dist/client.js

@@ -327,7 +327,6 @@ export { updateProfileSchema } from "./features/account/index.js";
 export { MediaImage } from "./features/media/index.js";
 export { StoreSidebar } from "./features/seller/components/SellerSidebar.js";
 export { StoreProductsView, StoreAboutView } from "./features/stores/index.js";
-export { SearchView } from "./features/search/index.js";
 /*
  * The browser-side search index. Exported from its DEFINING module rather
  * than through `features/search/index` (Root Cause #18) — `ensureSearchIndex`
@@ -336,6 +335,8 @@ export { SearchView } from "./features/search/index.js";
  * fetch per page session" guarantee quietly becomes two.
  */
 export { useSearchIndex, ensureSearchIndex } from "./features/search/hooks/useSearchIndex.js";
+export { useSiteSearch } from "./features/search/hooks/useSiteSearch.js";
+export { useScopedSearch, mergeSearchTiers } from "./features/search/hooks/useScopedSearch.js";
 export { AdSlot } from "./features/homepage/components/AdSlot.js";
 export { useActiveAd } from "./features/homepage/hooks/useActiveAd.js";
 export { registerAdSlot, registerAdSlots, unregisterAdSlot, clearAdRegistry, setAdConsentGranted, isAdConsentGranted, isAdSlotRenderable, } from "./features/homepage/ad-registry.js";
@@ -466,6 +467,7 @@ export { SellerBundlesView } from "./features/seller/components/SellerBundlesVie
 export { SellerClassifiedView } from "./features/seller/components/SellerClassifiedView.js";
 export { SellerArtView } from "./features/seller/components/SellerArtView.js";
 export { SellerStickersView } from "./features/seller/components/SellerStickersView.js";
+export { SellerSparesView } from "./features/seller/components/SellerSparesView.js";
 export { SellerDigitalCodesView } from "./features/seller/components/SellerDigitalCodesView.js";
 export { SellerLiveView } from "./features/seller/components/SellerLiveView.js";
 // ── Central schema registry (W1) ──────────────────────────────────────────────
@@ -502,6 +504,7 @@ export { computeCodHandlingFee } from "./_internal/shared/fees/calculator.js"; /
 export { FAQPageContent } from "./features/faq/index.js";
 export { CategoryInlineSelect } from "./features/seller/components/CategoryInlineSelect.js";
 export { CategoryTemplatePicker, variantForCondition } from "./features/categories/components/CategoryTemplatePicker.js";
+export { PriceGuidanceHint } from "./features/categories/components/PriceGuidanceHint.js";
 export { BrandInlineSelect } from "./features/seller/components/BrandInlineSelect.js";
 export { API_ENDPOINTS } from "./constants/index.js";
 // [CLIENT-SAFE] Pure, zero-import constant files — dashboard filter-tab