@mohasinac/appkit 4.53.0 → 4.53.1

package/dist/_internal/shared/features/products/group-rules.js

@@ -0,0 +1,142 @@
+/*
+ * WHY: "Create your own bundle, with restrictions set by seller/admin" is the
+ *      feature. The restrictions have TWO homes — a product group is identified
+ *      by the parent product's slug, while a `groupedListing` is its own
+ *      document — and the picker, the cart-add and the checkout re-validation
+ *      all have to agree about them.
+ * WHAT: One shape, one resolver, one enforcer. Three readers, zero copies.
+ *
+ * 🛑 THE SAME RULES, FROM EITHER HOME. Resolving them at each call site is how
+ * a picker ends up permitting a selection the server then refuses (or worse,
+ * the reverse — a server-only rule reads as a broken button). `resolveGroupRules`
+ * is the only place the two homes are read, and `checkGroupRules` is the only
+ * place they are applied.
+ *
+ * 🛑 EVERY FIELD IS OPTIONAL AND ABSENT MEANS UNRESTRICTED. Every group that
+ * exists today has none of these, so a default that restricted anything would
+ * silently change what is buyable on live records.
+ *
+ * EXPORTS: GroupRules, GroupRuleSource, GroupRuleViolation, EMPTY_GROUP_RULES,
+ *          readGroupRules, checkGroupRules, describeGroupRules
+ *
+ * @tag domain:products
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:GroupMemberPicker,cart-actions,checkout
+ * @tag sideEffects:none
+ */
+export const EMPTY_GROUP_RULES = {};
+/**
+ * Read the rules off either home.
+ *
+ * Structurally typed on purpose: a product group's rules live on the PARENT
+ * product document and a grouped listing's on its own, and both are just
+ * objects carrying these optional keys. Taking `ProductDocument |
+ * GroupedListingDocument` here would drag two feature schemas into a shared
+ * module for no gain — and this module is imported by a client component.
+ */
+export function readGroupRules(doc) {
+    if (!doc)
+        return EMPTY_GROUP_RULES;
+    const out = {};
+    /*
+     * Copied field by field rather than spread. A spread of the whole parent
+     * PRODUCT document would carry ~90 unrelated fields into something named
+     * "rules", and the next reader would reasonably assume everything on it was
+     * a rule.
+     */
+    if (typeof doc.groupMinMembers === "number")
+        out.groupMinMembers = doc.groupMinMembers;
+    if (typeof doc.groupMaxMembers === "number")
+        out.groupMaxMembers = doc.groupMaxMembers;
+    if (typeof doc.groupMaxUnitsPerMember === "number") {
+        out.groupMaxUnitsPerMember = doc.groupMaxUnitsPerMember;
+    }
+    if (Array.isArray(doc.groupRequiredMemberIds) && doc.groupRequiredMemberIds.length > 0) {
+        out.groupRequiredMemberIds = [...doc.groupRequiredMemberIds];
+    }
+    if (typeof doc.groupDiscountPercent === "number") {
+        out.groupDiscountPercent = doc.groupDiscountPercent;
+    }
+    return out;
+}
+/**
+ * Check a selection against the rules.
+ *
+ * Returns ALL violations rather than the first, because a picker shows them
+ * together and fixing one at a time is a worse experience than seeing the set.
+ * The server throws on the first; that is the caller's choice, not this
+ * function's.
+ *
+ * Entries at quantity 0 are ignored — the picker's stepper has `min={0}` and
+ * zero means "not chosen", so counting them would make an untouched member
+ * count toward `groupMinMembers`.
+ */
+export function checkGroupRules(rules, selection) {
+    const chosen = selection.filter((e) => e.quantity > 0);
+    const out = [];
+    if (rules.groupMinMembers !== undefined && chosen.length < rules.groupMinMembers) {
+        out.push({
+            code: "GROUP_TOO_FEW_MEMBERS",
+            message: `Pick at least ${rules.groupMinMembers} different item${rules.groupMinMembers === 1 ? "" : "s"} from this group — you have ${chosen.length}.`,
+        });
+    }
+    if (rules.groupMaxMembers !== undefined && chosen.length > rules.groupMaxMembers) {
+        out.push({
+            code: "GROUP_TOO_MANY_MEMBERS",
+            message: `Pick at most ${rules.groupMaxMembers} different item${rules.groupMaxMembers === 1 ? "" : "s"} from this group — you have ${chosen.length}.`,
+        });
+    }
+    if (rules.groupMaxUnitsPerMember !== undefined) {
+        for (const entry of chosen) {
+            if (entry.quantity > rules.groupMaxUnitsPerMember) {
+                out.push({
+                    code: "GROUP_MEMBER_QTY_EXCEEDED",
+                    message: `At most ${rules.groupMaxUnitsPerMember} of "${entry.title ?? entry.productId}" per order.`,
+                });
+            }
+        }
+    }
+    if (rules.groupRequiredMemberIds) {
+        const present = new Set(chosen.map((e) => e.productId));
+        const missing = rules.groupRequiredMemberIds.filter((id) => !present.has(id));
+        if (missing.length > 0) {
+            /*
+             * Named by id when the caller has no title for it — which is the normal
+             * case, because a REQUIRED member the buyer has not chosen is not in
+             * their selection and so has no entry to read a title from. The picker
+             * passes titles it already has; the server does not have them and says
+             * so honestly rather than printing "undefined".
+             */
+            const titles = missing.map((id) => selection.find((e) => e.productId === id)?.title ?? id);
+            out.push({
+                code: "GROUP_REQUIRED_MEMBER_MISSING",
+                message: `This group requires ${titles.join(", ")} to be included.`,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * The rules in words, for the picker's header.
+ *
+ * Returns an empty array when nothing is restricted, so the caller renders
+ * nothing rather than an empty box saying "Rules:".
+ */
+export function describeGroupRules(rules) {
+    const out = [];
+    if (rules.groupMinMembers !== undefined) {
+        out.push(`Pick at least ${rules.groupMinMembers}`);
+    }
+    if (rules.groupMaxMembers !== undefined) {
+        out.push(`Pick at most ${rules.groupMaxMembers}`);
+    }
+    if (rules.groupMaxUnitsPerMember !== undefined) {
+        out.push(`Max ${rules.groupMaxUnitsPerMember} of each`);
+    }
+    if (rules.groupDiscountPercent !== undefined && rules.groupDiscountPercent > 0) {
+        out.push(`${rules.groupDiscountPercent}% off the selection`);
+    }
+    return out;
+}

package/dist/_internal/shared/listing-types/_registry.d.ts

@@ -108,6 +108,30 @@ export interface ListingTypePlugin {
      * reachable only by typing the URL.
      */
     inGeneralCatalogue: boolean;
+    /**
+     * May a listing of this type be a MEMBER of a product group?
+     *
+     * A product group is "a whole plus its parts, buy any mix" — a sticker sheet
+     * with its cut-out stickers, a complete Beyblade with its spares. The buyer
+     * picks quantities per member through `GroupMemberPicker`.
+     *
+     * 🛑 `findByGroupId` used to hard-code `["standard", "pre-order"]`, which
+     * made this field's answer invisible and wrong: a `stickers` or `art` member
+     * was silently dropped from the query, so `ShowGroupSection` saw one member
+     * and returned null — the picker was unreachable with nothing erroring. That
+     * is Root Cause #58's shape, a union member missing from the one allowlist
+     * that gates it.
+     *
+     * Required, not optional, for the same reason as `inGeneralCatalogue`: a
+     * tenth type must not compile until someone decides.
+     *
+     * False where the type's own pricing or lifecycle makes "pick N of these"
+     * meaningless — an auction is one unique lot, a pre-order is a deposit
+     * against a future release, a prize-draw sells entries, a classified has no
+     * cart, a digital-code is a fungible pool, and a live item is
+     * jurisdiction-gated per buyer.
+     */
+    canJoinProductGroup: boolean;
     /**
      * Leading glyph for this type's chip, tab and dropdown row.
      *

package/dist/_internal/shared/listing-types/_registry.js

@@ -32,6 +32,8 @@ import * as live from "./live/config.js";
 // EMI/art-stickers session — printed-only physical-goods types.
 import * as art from "./art/config.js";
 import * as stickers from "./stickers/config.js";
+// Part Two 2026-10-19 — one component off a disassembled item, sold alone.
+import * as spares from "./spares/config.js";
 import { LISTING_TYPE_CAPABILITIES } from "./capabilities.js";
 import { baseAvailable, } from "./availability.js";
 import { AVAILABILITY_VALUES, } from "../../../constants/field-names.js";
@@ -48,9 +50,45 @@ export const LISTING_TYPE_REGISTRY = {
     live: live.config,
     art: art.config,
     stickers: stickers.config,
+    spares: spares.config,
 };
+/*
+ * 🛑 TOTAL BY CONSTRUCTION — this was a bare index lookup and it crashed pages.
+ *
+ * The signature says `(type: ListingType) => ListingTypePlugin`, and for a
+ * value the compiler has actually checked that is true. But most callers get
+ * their `listingType` from a Firestore document, which crosses into the app
+ * as untyped data: a row written before a type existed, a row whose field was
+ * stripped by a `z.object()` schema, or a mapper that forgot to copy the
+ * field (Root Cause #48) all arrive as `undefined`. The lookup then returned
+ * `undefined` while TypeScript still believed it held a plugin, so the very
+ * next property access threw.
+ *
+ * Measured in production over 24h: 18 server-side crashes reading
+ * `.detailRoute` of undefined, across FIVE route families
+ * (`products/[slug]`, `classified/[slug]`, `pre-orders/[id]`,
+ * `digital-codes/[slug]`, `prize-draws/[slug]`), plus client-side copies of
+ * the same throw and one on `.badge` from `franchise/[slug]`. Each one is a
+ * whole detail page replaced by an error boundary.
+ *
+ * Falling back to `standard` is right because it is what the rest of the
+ * codebase ALREADY assumes: `normalizeListingType` is defined as
+ * `p.listingType ?? "standard"`, so a missing field is a standard listing
+ * everywhere else. Callers that pass through it were always safe; this makes
+ * the ones that do not safe as well.
+ *
+ * 🛑 It WARNS rather than falling back silently. A silent default is how a
+ * tenth listing type goes missing from the catalogue for weeks (Root Cause
+ * #58, where an unmapped alias returned "" and the filter simply vanished).
+ * The page renders; the gap is still reported.
+ */
 export function pluginFor(type) {
-    return LISTING_TYPE_REGISTRY[type];
+    const plugin = LISTING_TYPE_REGISTRY[type];
+    if (plugin)
+        return plugin;
+    console.warn(`[listing-types] no plugin for listingType ${JSON.stringify(type)} — ` +
+        `falling back to "standard". Expected one of: ${Object.keys(LISTING_TYPE_REGISTRY).join(", ")}.`);
+    return LISTING_TYPE_REGISTRY.standard;
 }
 /**
  * Infer a listing type from a product slug/id by matching its registered

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

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

package/dist/_internal/shared/listing-types/art/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,
+    // a print can be one of a set, and a sheet of art can be split
+    canJoinProductGroup: true,
     iconKey: "art",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared

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

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

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

@@ -22,6 +22,8 @@ export const config = {
     // /auctions is in MAIN_NAV_ITEMS. An auction card in the general grid renders
     // Buy-Now chrome rather than bid affordances, so it belongs on its own page.
     inGeneralCatalogue: false,
+    // one unique lot, won by one bidder — there is no "pick 3 of these"
+    canJoinProductGroup: false,
     iconKey: "bid",
     // An auction is never "sold out" — it ends. Hiding by stock would hide
     // every live auction, since auctions don't carry meaningful stock.

package/dist/_internal/shared/listing-types/availability.js

@@ -67,8 +67,32 @@ export function num(value) {
  * and must not vanish from the default scope.
  */
 export function baseAvailable(row) {
+    /*
+     * `isSold` stays the kill switch and is tested FIRST, ahead of the
+     * made-to-order bypass. A seller who marks a listing sold has made a
+     * statement about the listing, not about its stock level, and it must hold
+     * whatever the production model is — otherwise a made-to-order row could
+     * never be retired at all.
+     */
     if (row[PRODUCT_FIELDS.IS_SOLD] === true)
         return false;
+    /*
+     * 🛑 Made to order: stock does not gate availability, so return before the
+     * two quantity checks.
+     *
+     * This ONE branch fixes `isListingRowAvailable`, the dense `available`
+     * scope, all three homepage `getFeatured*` helpers and related-items at
+     * once, because every one of them resolves to this function — which is the
+     * entire reason the four disagreeing copies were collapsed into it (Root
+     * Cause #73). It also correctly keeps a made-to-order row OUT of "Sold &
+     * Ended": that scope is the complement of this predicate.
+     *
+     * The counter-case is the point of the flag being per-listing: a finite
+     * spare at quantity 0 is genuinely gone and still falls through to the
+     * checks below.
+     */
+    if (row[PRODUCT_FIELDS.MADE_TO_ORDER] === true)
+        return true;
     const available = num(row[PRODUCT_FIELDS.AVAILABLE_QUANTITY]);
     if (available !== null && available <= 0)
         return false;
@@ -94,6 +118,30 @@ export const STOCK_ONLY_UNAVAILABLE_CLAUSES = [
     { field: PRODUCT_FIELDS.AVAILABLE_QUANTITY, op: "eq", value: 0 },
     { field: PRODUCT_FIELDS.IS_SOLD, op: "eq", value: true },
 ];
+/*
+ * 🛑 WHY `madeToOrder` IS NOT A CLAUSE HERE, written down so nobody
+ * "optimises" it into a FAILED_PRECONDITION.
+ *
+ * A made-to-order row at quantity 0 still matches the first clause above, so it
+ * is fetched by the "Sold & Ended" query and then dropped in memory by
+ * `baseAvailable`. That is wasteful and it is CORRECT.
+ *
+ * The apparent fix — adding `madeToOrder != true` to narrow the query — cannot
+ * be expressed: `!=` is an INEQUALITY, so `UnavailableClause` would require it
+ * to name its own `sortField`, and Firestore implicitly appends an
+ * inequality's field to the `orderBy`. Pairing it with the scope's real sort
+ * demands a composite index in an order nobody declares (Root Cause #59), and
+ * every caller wraps the query in a guard that turns the failure into an empty
+ * page rather than an error.
+ *
+ * Worse, a Firestore inequality EXCLUDES every document that lacks the field —
+ * which is every product written before this flag existed, i.e. all of them.
+ * `madeToOrder != true` would return almost nothing. Same trap as the
+ * `isTestData` one CLAUDE.md documents.
+ *
+ * The in-memory drop is bounded by the page size, so the cost is a few rows
+ * read and discarded. Leave it.
+ */
 /**
  * `isAvailable` for a type with no rule beyond `baseAvailable`. Named rather
  * than an inline `() => true` so the five configs that use it read as

package/dist/_internal/shared/listing-types/capabilities.js

@@ -11,6 +11,25 @@
  * inside the per-type folder (X2 plugin layout).
  */
 export const LISTING_TYPE_CAPABILITIES = {
+    /*
+     * Standard physical-goods behaviour, with ONE deliberate difference:
+     * `canMakeOffer` is true.
+     *
+     * A loose part has no catalogue price — what a spare attack ring is worth
+     * depends on the colour, the wear and how badly the buyer needs that exact
+     * one. It is the archetypal haggled item here, which is the whole reason the
+     * seller is listing it instead of leaving it in a drawer, so the type that
+     * most needs Make-an-Offer is this one.
+     */
+    spares: {
+        canAddToCart: true,
+        canBid: false,
+        supportsShipping: true,
+        requiresVendorVerified: false,
+        requiresJurisdictionCheck: false,
+        hasInstantFulfillment: false,
+        canMakeOffer: true,
+    },
     standard: {
         canAddToCart: true,
         canBid: false,

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

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

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

@@ -21,6 +21,8 @@ export const config = {
     // Has a dedicated page but NO MAIN_NAV_ITEMS entry, so /products is its only
     // discovery path. Dropping it here would orphan the type (Root Cause #61).
     inGeneralCatalogue: true,
+    // no cart at all (cartLine "blocked") — the purchase path is contact-seller
+    canJoinProductGroup: false,
     iconKey: "deals",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared

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

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

package/dist/_internal/shared/listing-types/digital-code/config.js

@@ -34,6 +34,8 @@ export const config = {
     // Has a dedicated page but NO MAIN_NAV_ITEMS entry, so /products is its only
     // discovery path. Dropping it here would orphan the type (Root Cause #61).
     inGeneralCatalogue: true,
+    // a fungible pool item; "which 3 of these codes" is not a question a buyer has
+    canJoinProductGroup: false,
     iconKey: "digitalCode",
     // "Sold out" for a code pool means codesAvailable hit 0. That was ASSUMED to
     // be mirrored by stockQuantity, and it isn't — seed and production rows exist

package/dist/_internal/shared/listing-types/feature-flags.js

@@ -44,6 +44,7 @@ export function isCategoryTypeEnabled(type, settings) {
  */
 const ALL_LISTING_TYPES_MAP = {
     standard: true,
+    spares: true,
     auction: true,
     "pre-order": true,
     "prize-draw": true,

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

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

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

@@ -21,6 +21,8 @@ export const config = {
     // Has a dedicated page but NO MAIN_NAV_ITEMS entry, so /products is its only
     // discovery path. Dropping it here would orphan the type (Root Cause #61).
     inGeneralCatalogue: true,
+    // jurisdiction-gated per buyer and vendor-verified — not mixable into a group line
+    canJoinProductGroup: false,
     iconKey: "live",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared

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;