@mohasinac/appkit 4.70.0 → 4.71.2

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

@@ -0,0 +1,46 @@
+import { LISTING_TYPE_CAPABILITIES } from "../capabilities.js";
+import { ROUTES } from "../../../../next/routing/route-map.js";
+import { TABLE_KEYS } from "../../../../constants/table-keys.js";
+import { PRODUCT_FIELDS } from "../../../../constants/field-names.js";
+import { CLEARANCE_SORT_OPTIONS, CLEARANCE_PUBLIC_SORT_OPTIONS, } from "../../../../features/products/constants/sieve.js";
+export const LISTING_TYPE = "clearance";
+export const capability = LISTING_TYPE_CAPABILITIES["clearance"];
+export const config = {
+    listingType: LISTING_TYPE,
+    slugPrefix: "clearance-",
+    cartLine: "single-product",
+    detailRoute: (idOrSlug) => String(ROUTES.PUBLIC.CLEARANCE_DETAIL(idOrSlug)),
+    badge: { label: "Clearance", className: "bg-primary text-white" },
+    priceLabel: "Price (₹)",
+    typeLabel: "Clearance",
+    showsStockQuantity: false,
+    tabSlug: "clearance",
+    pluralLabel: "Clearance",
+    chipLabel: "Clearance",
+    browseRoute: String(ROUTES.PUBLIC.CLEARANCE),
+    // /clearance 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: "clearance",
+    primaryActionKind: "enter-draw",
+    hideDefault: "closed",
+    // `prizeRevealStatus`, NOT remaining entries: a draw can close with slots
+    // unsold (the seller ends it early, or the reveal window lapses), and it can
+    // sell every slot while still open pending the reveal. Only the status field
+    // answers "can someone still enter this".
+    isAvailable: (row) => row[PRODUCT_FIELDS.PRIZE_REVEAL_STATUS] !==
+        PRODUCT_FIELDS.PRIZE_REVEAL_STATUS_VALUES.CLOSED,
+    unavailableClauses: [
+        {
+            field: PRODUCT_FIELDS.PRIZE_REVEAL_STATUS,
+            op: "eq",
+            value: PRODUCT_FIELDS.PRIZE_REVEAL_STATUS_VALUES.CLOSED,
+        },
+        { field: PRODUCT_FIELDS.AVAILABLE_QUANTITY, op: "eq", value: 0 },
+    ],
+    sortOptions: CLEARANCE_SORT_OPTIONS,
+    publicSortOptions: CLEARANCE_PUBLIC_SORT_OPTIONS,
+    extraFacetKeys: [TABLE_KEYS.PRIZE_REVEAL_STATUS],
+};

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

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

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

@@ -0,0 +1,13 @@
+export function isClearanceProduct(doc) {
+    return doc.listingType === "clearance";
+}
+// True when entries are still accepted (reveal window has not started, slots not exhausted).
+export function isOpenClearance(doc) {
+    if (!isClearanceProduct(doc))
+        return false;
+    const max = doc.prizeMaxEntries ?? null;
+    const current = doc.prizeCurrentEntries ?? 0;
+    if (typeof max === "number" && current >= max)
+        return false;
+    return !doc.prizeRevealWindowStart || doc.prizeRevealWindowStart > new Date();
+}

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

@@ -0,0 +1,85 @@
+import { type AvailabilityRow } from "../availability";
+export declare const LISTING_TYPE: "collector-drop";
+export declare const capability: import("../capabilities").ListingTypeCapability;
+export declare const config: {
+    listingType: "collector-drop";
+    slugPrefix: string;
+    cartLine: "blocked";
+    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: "bid";
+    primaryActionKind: "bid";
+    hideDefault: "ended";
+    isAvailable: (row: AvailabilityRow, now: Date) => boolean;
+    unavailableClauses: ({
+        field: "collectorDropEndDate";
+        op: "lt";
+        value: "NOW";
+        sortField: "collectorDropEndDate";
+    } | {
+        field: "isSold";
+        op: "eq";
+        value: boolean;
+        sortField?: undefined;
+    })[];
+    sortOptions: readonly [{
+        readonly value: string;
+        readonly label: "Ending Soon";
+    }, {
+        readonly value: string;
+        readonly label: "Just Started";
+    }, {
+        readonly value: string;
+        readonly label: "Lowest Current Bid";
+    }, {
+        readonly value: string;
+        readonly label: "Highest Current Bid";
+    }, {
+        readonly value: string;
+        readonly label: "Lowest Starting Bid";
+    }, {
+        readonly value: string;
+        readonly label: "Most Bids";
+    }, {
+        readonly value: string;
+        readonly label: "Fewest Bids";
+    }, {
+        readonly value: string;
+        readonly label: "Buy It Now: Low–High";
+    }, {
+        readonly value: string;
+        readonly label: "Oldest Listed";
+    }];
+    publicSortOptions: readonly [{
+        readonly value: string;
+        readonly label: "Ending Soon";
+    }, {
+        readonly value: string;
+        readonly label: "Just Started";
+    }, {
+        readonly value: string;
+        readonly label: "Lowest Current Bid";
+    }, {
+        readonly value: string;
+        readonly label: "Highest Current Bid";
+    }, {
+        readonly value: string;
+        readonly label: "Most Bids";
+    }, {
+        readonly value: string;
+        readonly label: "Buy It Now: Low–High";
+    }];
+    extraFacetKeys: readonly string[];
+};

package/dist/_internal/shared/listing-types/collector-drop/config.js

@@ -0,0 +1,59 @@
+import { LISTING_TYPE_CAPABILITIES } from "../capabilities.js";
+import { toDate } from "../availability.js";
+import { ROUTES } from "../../../../next/routing/route-map.js";
+import { TABLE_KEYS } from "../../../../constants/table-keys.js";
+import { PRODUCT_FIELDS } from "../../../../constants/field-names.js";
+import { COLLECTOR_DROP_SORT_OPTIONS, COLLECTOR_DROP_PUBLIC_SORT_OPTIONS, } from "../../../../features/products/constants/sieve.js";
+export const LISTING_TYPE = "collector-drop";
+export const capability = LISTING_TYPE_CAPABILITIES["collector-drop"];
+export const config = {
+    listingType: LISTING_TYPE,
+    slugPrefix: "collectordrop-",
+    cartLine: "blocked",
+    detailRoute: (idOrSlug) => String(ROUTES.PUBLIC.COLLECTOR_DROP_DETAIL(idOrSlug)),
+    badge: { label: "Collector Drop", className: "bg-warning-solid text-warning-on-solid" },
+    priceLabel: "Suggested Retail Price (₹)",
+    typeLabel: "Collector Drop",
+    showsStockQuantity: false,
+    tabSlug: "collector-drops",
+    pluralLabel: "Collector Drops",
+    chipLabel: "Collector Drops",
+    browseRoute: String(ROUTES.PUBLIC.COLLECTOR_DROPS),
+    // /collector-drops is in MAIN_NAV_ITEMS. A collector drop 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",
+    primaryActionKind: "bid",
+    // A collector drop is never "sold out" — it ends. Hiding by stock would hide
+    // every live collector drop, since collector drops don't carry meaningful stock.
+    hideDefault: "ended",
+    // There is no `collectorDropStatus` field — "ended" is purely the end date having
+    // passed. A collector drop with no end date at all is treated as live rather than
+    // hidden; a missing date is a data defect, not a signal that it is over.
+    isAvailable: (row, now) => {
+        const end = toDate(row[PRODUCT_FIELDS.COLLECTOR_DROP_END_DATE]);
+        return end === null || end > now;
+    },
+    unavailableClauses: [
+        // The ONLY inequality in the registry — safe because it names the sort
+        // field the query must order by, which is also the natural sort for an
+        // "ended collector drops" archive ("Recently Ended").
+        {
+            field: PRODUCT_FIELDS.COLLECTOR_DROP_END_DATE,
+            op: "lt",
+            value: "NOW",
+            sortField: PRODUCT_FIELDS.COLLECTOR_DROP_END_DATE,
+        },
+        { field: PRODUCT_FIELDS.IS_SOLD, op: "eq", value: true },
+    ],
+    sortOptions: COLLECTOR_DROP_SORT_OPTIONS,
+    publicSortOptions: COLLECTOR_DROP_PUBLIC_SORT_OPTIONS,
+    extraFacetKeys: [
+        TABLE_KEYS.MIN_BID,
+        TABLE_KEYS.MAX_BID,
+        TABLE_KEYS.DATE_FROM,
+        TABLE_KEYS.DATE_TO,
+    ],
+};

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

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

package/dist/_internal/shared/listing-types/collector-drop/schema.js

@@ -0,0 +1,11 @@
+export function isCollectorDropProduct(doc) {
+    // Accepts the pre-rename "auction" spelling too: a document written before
+    // the rename still carries it (see LISTING_KIND_ALIAS_MAP).
+    return ((doc.listingType === "collector-drop" ||
+        doc.listingType === "auction") &&
+        doc.collectorDropEndDate != null);
+}
+// True when the collector drop end date is in the future — gates the Bid button.
+export function isActiveCollectorDrop(doc) {
+    return isCollectorDropProduct(doc) && doc.collectorDropEndDate > new Date();
+}

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

@@ -20,6 +20,7 @@ export declare const config: {
     inGeneralCatalogue: boolean;
     canJoinProductGroup: boolean;
     iconKey: "digitalCode";
+    primaryActionKind: "buy-now";
     hideDefault: "sold";
     isAvailable: (row: AvailabilityRow) => boolean;
     unavailableClauses: ({

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

@@ -37,6 +37,7 @@ export const config = {
     // a fungible pool item; "which 3 of these codes" is not a question a buyer has
     canJoinProductGroup: false,
     iconKey: "digitalCode",
+    primaryActionKind: "buy-now",
     // "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
     // with a drained pool and non-zero stock. The pool count is authoritative.

package/dist/_internal/shared/listing-types/feature-flags.d.ts

@@ -20,11 +20,67 @@
  */
 import type { ListingType } from "../../../features/products/types/index";
 import type { CategoryType } from "../../../features/categories/types/index";
-interface FeatureFlagSnapshot {
+/**
+ * Three states, not two. `true`/absent is fully open; `false` closes the
+ * surface outright (404, dropped from nav/sitemap); `"unlisted"` sits
+ * between them — the surface keeps serving (a direct link a customer
+ * already holds, an order confirmation, a bookmark, must not 404 just
+ * because a type was deprioritized) but is withdrawn from nav, footer and
+ * the sitemap, same as `false` for discovery purposes.
+ */
+export type FlagValue = boolean | "unlisted";
+/**
+ * The three states as an ADMIN-EDITABLE choice.
+ *
+ * 🛑 This exists because the third state had no control surface. `"unlisted"`
+ * has been a real stored value since 2026-11-07, read correctly by
+ * `isListingTypeEnabled` / `isListingTypeListed` — but the admin Listings tab
+ * rendered each flag as a two-state `Toggle` (`checked={flags[key] ?? true}`),
+ * which means:
+ *
+ *   · a stored `"unlisted"` is a truthy STRING, so the toggle drew it as fully
+ *     ON — an admin could not tell "unlisted" from "listed"; and
+ *   · flipping that toggle wrote a `boolean`, DESTROYING the third state with
+ *     no way to put it back.
+ *
+ * So the state the owner asked for ("do not show their links or filters, but
+ * do not 404 their pages") was reachable only by editing Firestore by hand.
+ * A capability that is data but has no control is still a code change in
+ * practice, which is exactly what the governing principle forbids.
+ *
+ * Deliberately generic over all THREE flag axes (listing types, category
+ * types, browse pages). All three are declared `boolean | "unlisted"` and all
+ * three had the same two-state renderer, so a listing-type-only fix would
+ * leave two divergent copies of the same bug.
+ */
+export type FlagChoice = "listed" | "unlisted" | "off";
+/**
+ * Option list for a three-state admin control, in deliberate order
+ * most-open → most-closed.
+ *
+ * Labels say what each state DOES rather than naming the stored value: an
+ * admin choosing between "unlisted" and "off" needs to know one still serves
+ * the page and the other 404s it, and that distinction is the whole reason
+ * the third state exists.
+ */
+export declare const FLAG_CHOICE_OPTIONS: ReadonlyArray<{
+    value: FlagChoice;
+    label: string;
+}>;
+/**
+ * Stored value → choice. `undefined` maps to `"listed"`, matching the
+ * absent-means-enabled contract every reader in this file already honours.
+ */
+export declare function flagValueToChoice(value: FlagValue | undefined): FlagChoice;
+/** Choice → stored value. The exact inverse of `flagValueToChoice`. */
+export declare function choiceToFlagValue(choice: FlagChoice): FlagValue;
+/** Narrow an untrusted string (a form value) to a `FlagChoice`. */
+export declare function isFlagChoice(value: unknown): value is FlagChoice;
+export interface FeatureFlagSnapshot {
     listings?: {
-        listingTypes?: Partial<Record<ListingType, boolean>>;
-        categoryTypes?: Partial<Record<CategoryType, boolean>>;
-        browsePages?: Partial<Record<BrowsePageKey, boolean>>;
+        listingTypes?: Partial<Record<ListingType, FlagValue>>;
+        categoryTypes?: Partial<Record<CategoryType, FlagValue>>;
+        browsePages?: Partial<Record<BrowsePageKey, FlagValue>>;
     };
 }
 /**
@@ -34,7 +90,7 @@ interface FeatureFlagSnapshot {
  * distinction is what stops it becoming a duplicate control:
  *
  *   `listingTypes`  — what the marketplace SELLS (is there such a thing as an
- *                     auction here?)
+ *                     collector drop here?)
  *   `categoryTypes` — what a taxonomy ROW may be (may a category row be a
  *                     brand?)
  *   `browsePages`   — whether a public ENTRY POINT is open (is there a /brands
@@ -62,6 +118,20 @@ export declare const ALL_BROWSE_PAGES: BrowsePageKey[];
  * from it.
  */
 export declare function isBrowsePageEnabled(page: BrowsePageKey, settings: FeatureFlagSnapshot | null | undefined): boolean;
+/**
+ * Should this section appear in nav/footer/the sitemap? `false` and
+ * `"unlisted"` both answer no — only the absent-or-`true` default is listed.
+ * A direct link still resolves either way; `isBrowsePageEnabled` above is
+ * what the 404 gate reads, and it is deliberately untouched by this
+ * function.
+ */
+export declare function isBrowsePageListed(page: BrowsePageKey, settings: FeatureFlagSnapshot | null | undefined): boolean;
+/**
+ * Which sections to actually show links for — nav, footer, sitemap. Reads
+ * `isBrowsePageListed`, not `isBrowsePageEnabled`: an `"unlisted"` section's
+ * own page still serves at 200 (that's what `isBrowsePageEnabled` and the
+ * 404 gate in `closedSurfacePrefixes` answer), it just stops appearing here.
+ */
 export declare function enabledBrowsePages(settings: FeatureFlagSnapshot | null | undefined): BrowsePageKey[];
 /** Narrow an untrusted string — a route param, a form value — to the union. */
 export declare function isBrowsePageKey(value: unknown): value is BrowsePageKey;
@@ -98,7 +168,15 @@ export declare function browsePageForPath(href: string | undefined | null): Brow
  * EXPLICITLY set to `false` to disable a type.
  */
 export declare function isListingTypeEnabled(type: ListingType, settings: FeatureFlagSnapshot | null | undefined): boolean;
+/**
+ * Should this type appear in nav/footer/the sitemap? `false` and
+ * `"unlisted"` both answer no. `isListingTypeEnabled` above is still what
+ * the 404 gate reads — an unlisted type keeps serving existing detail
+ * pages, it just stops being advertised as a place to browse.
+ */
+export declare function isListingTypeListed(type: ListingType, settings: FeatureFlagSnapshot | null | undefined): boolean;
 export declare function isCategoryTypeEnabled(type: CategoryType, settings: FeatureFlagSnapshot | null | undefined): boolean;
+export declare function isCategoryTypeListed(type: CategoryType, settings: FeatureFlagSnapshot | null | undefined): boolean;
 export declare const ALL_LISTING_TYPES: ListingType[];
 /**
  * Narrow an untrusted string — a `?listingType=` param, a form value — to a
@@ -109,6 +187,22 @@ export declare const ALL_LISTING_TYPES: ListingType[];
 export declare function isListingType(value: unknown): value is ListingType;
 /** Pull the full list of enabled listing types in canonical iteration order. */
 export declare function enabledListingTypes(settings: FeatureFlagSnapshot | null | undefined): ListingType[];
+/**
+ * The listing types a visitor may be OFFERED a way into — tabs, chips, filter
+ * options, nav entries.
+ *
+ * 🛑 The counterpart of `enabledListingTypes`, and the distinction is the one
+ * that review found being lost: `enabled` stays TRUE for `"unlisted"` (its
+ * pages must keep serving), so a tab list built from `enabledListingTypes`
+ * silently re-advertises every type an admin just unlisted. `enabled` is the
+ * right answer for a QUERY span or an authoring control; this is the right
+ * answer for anything a visitor clicks.
+ *
+ * Sits BELOW `visibleListingTypes`, which additionally drops types measured
+ * empty — use that one where a count snapshot is available, this one where
+ * the caller does its own count-based hiding (the category/brand tab bars).
+ */
+export declare function listedListingTypes(settings: FeatureFlagSnapshot | null | undefined): ListingType[];
 /**
  * The measured counts, as the public site-settings payload carries them.
  *
@@ -146,13 +240,36 @@ export declare function isListingSurfaceVisible(type: ListingType, settings: Fea
  */
 export declare function isCountedSurfaceVisible(surface: string, counts: SurfaceCountSnapshot | null | undefined): boolean;
 /**
- * Visible listing types — the flag list, minus the ones measured empty.
+ * Visible listing types — the flag list, minus the ones measured empty,
+ * minus the ones set to `"unlisted"`.
  *
  * This is what nav, footer and the sitemap filter on. `enabledListingTypes`
  * above is deliberately left alone: it answers "what does this marketplace
  * sell", which `/api/products`' post-filter and the seller forms still need
- * even for a type with zero rows today.
+ * even for a type with zero rows today. `isListingSurfaceVisible` (and
+ * therefore `hiddenSurfaceRoutes`'s 404 gate) is ALSO deliberately left
+ * alone — an `"unlisted"` type keeps serving its browse route and every
+ * detail page at 200, it only stops being advertised here.
  */
 export declare function visibleListingTypes(settings: FeatureFlagSnapshot | null | undefined, counts: SurfaceCountSnapshot | null | undefined): ListingType[];
+export declare const ALL_CATEGORY_TYPES: CategoryType[];
 export declare function enabledCategoryTypes(settings: FeatureFlagSnapshot | null | undefined): CategoryType[];
-export {};
+/**
+ * One operational row's visibility check (1A-iii) — for the ~50+ schemas
+ * that already carry the canonical `listingType`/`categoryType` scalar
+ * CLAUDE.md's "Listing Types Reference" documents, read by a PUBLIC-facing
+ * list. Reuses `isListingTypeEnabled`/`isCategoryTypeEnabled` directly rather
+ * than adding a second tag array to a transactional record — the row already
+ * names its own type, it just needs that name checked against the live flag
+ * at the query/render layer.
+ *
+ * 🛑 Deliberately NOT for genuinely operational, non-public surfaces (orders,
+ * cart, payments, shipments, ledger, audit-log, jobs) — a buyer must keep
+ * seeing their own past order for a since-closed listing type; filtering
+ * that by the live flag would be a regression, not a fix. Call this only
+ * from a public LIST/browse read path.
+ */
+export declare function isGovernedRowVisible(row: {
+    listingType?: string;
+    categoryType?: string;
+}, settings: FeatureFlagSnapshot | null | undefined): boolean;

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

@@ -21,6 +21,43 @@
 // Route-map only — a pure constants module with no firebase-admin in its
 // import chain, so this stays safe in the client bundle (appkit Export Rules).
 import { ROUTES } from "../../../next/routing/route-map.js";
+/**
+ * Option list for a three-state admin control, in deliberate order
+ * most-open → most-closed.
+ *
+ * Labels say what each state DOES rather than naming the stored value: an
+ * admin choosing between "unlisted" and "off" needs to know one still serves
+ * the page and the other 404s it, and that distinction is the whole reason
+ * the third state exists.
+ */
+export const FLAG_CHOICE_OPTIONS = [
+    { value: "listed", label: "Listed — browsable and advertised" },
+    { value: "unlisted", label: "Unlisted — pages still serve, no links" },
+    { value: "off", label: "Off — pages return Not Found" },
+];
+/**
+ * Stored value → choice. `undefined` maps to `"listed"`, matching the
+ * absent-means-enabled contract every reader in this file already honours.
+ */
+export function flagValueToChoice(value) {
+    if (value === false)
+        return "off";
+    if (value === "unlisted")
+        return "unlisted";
+    return "listed";
+}
+/** Choice → stored value. The exact inverse of `flagValueToChoice`. */
+export function choiceToFlagValue(choice) {
+    if (choice === "off")
+        return false;
+    if (choice === "unlisted")
+        return "unlisted";
+    return true;
+}
+/** Narrow an untrusted string (a form value) to a `FlagChoice`. */
+export function isFlagChoice(value) {
+    return value === "listed" || value === "unlisted" || value === "off";
+}
 /**
  * Declared as `Record<BrowsePageKey, true>` for the same reason
  * `ALL_LISTING_TYPES_MAP` is: adding a key to the union without adding it here
@@ -46,8 +83,25 @@ export const ALL_BROWSE_PAGES = Object.keys(ALL_BROWSE_PAGES_MAP);
 export function isBrowsePageEnabled(page, settings) {
     return settings?.listings?.browsePages?.[page] !== false;
 }
+/**
+ * Should this section appear in nav/footer/the sitemap? `false` and
+ * `"unlisted"` both answer no — only the absent-or-`true` default is listed.
+ * A direct link still resolves either way; `isBrowsePageEnabled` above is
+ * what the 404 gate reads, and it is deliberately untouched by this
+ * function.
+ */
+export function isBrowsePageListed(page, settings) {
+    const flag = settings?.listings?.browsePages?.[page];
+    return flag !== false && flag !== "unlisted";
+}
+/**
+ * Which sections to actually show links for — nav, footer, sitemap. Reads
+ * `isBrowsePageListed`, not `isBrowsePageEnabled`: an `"unlisted"` section's
+ * own page still serves at 200 (that's what `isBrowsePageEnabled` and the
+ * 404 gate in `closedSurfacePrefixes` answer), it just stops appearing here.
+ */
 export function enabledBrowsePages(settings) {
-    return ALL_BROWSE_PAGES.filter((p) => isBrowsePageEnabled(p, settings));
+    return ALL_BROWSE_PAGES.filter((p) => isBrowsePageListed(p, settings));
 }
 /** Narrow an untrusted string — a route param, a form value — to the union. */
 export function isBrowsePageKey(value) {
@@ -113,17 +167,32 @@ export function isListingTypeEnabled(type, settings) {
     const flag = settings?.listings?.listingTypes?.[type];
     return flag !== false;
 }
+/**
+ * Should this type appear in nav/footer/the sitemap? `false` and
+ * `"unlisted"` both answer no. `isListingTypeEnabled` above is still what
+ * the 404 gate reads — an unlisted type keeps serving existing detail
+ * pages, it just stops being advertised as a place to browse.
+ */
+export function isListingTypeListed(type, settings) {
+    const flag = settings?.listings?.listingTypes?.[type];
+    return flag !== false && flag !== "unlisted";
+}
 export function isCategoryTypeEnabled(type, settings) {
     const flag = settings?.listings?.categoryTypes?.[type];
     return flag !== false;
 }
+export function isCategoryTypeListed(type, settings) {
+    const flag = settings?.listings?.categoryTypes?.[type];
+    return flag !== false && flag !== "unlisted";
+}
 /**
  * Every listing type, in canonical iteration order.
  *
  * Declared as `Record<ListingType, true>` rather than a plain array on purpose:
  * adding a member to the `ListingType` union without adding it here is then a
- * COMPILE error, not a silent omission. `art` / `stickers` were missing from
- * the old hand-written array for exactly that reason, which meant
+ * COMPILE error, not a silent omission. `art-and-stickers` (then still two
+ * separate members) was missing from the old hand-written array for exactly
+ * that reason, which meant
  * `/api/products`' "strip disabled types" post-filter dropped every art and
  * sticker row from any call that didn't name a listingType explicitly
  * (homepage, search, related-items).
@@ -131,14 +200,13 @@ export function isCategoryTypeEnabled(type, settings) {
 const ALL_LISTING_TYPES_MAP = {
     standard: true,
     spares: true,
-    auction: true,
+    "collector-drop": true,
     "pre-order": true,
-    "prize-draw": true,
+    "clearance": true,
     classified: true,
     "digital-code": true,
     live: true,
-    art: true,
-    stickers: true,
+    "art-and-stickers": true,
 };
 export const ALL_LISTING_TYPES = Object.keys(ALL_LISTING_TYPES_MAP);
 /**
@@ -154,6 +222,24 @@ export function isListingType(value) {
 export function enabledListingTypes(settings) {
     return ALL_LISTING_TYPES.filter((t) => isListingTypeEnabled(t, settings));
 }
+/**
+ * The listing types a visitor may be OFFERED a way into — tabs, chips, filter
+ * options, nav entries.
+ *
+ * 🛑 The counterpart of `enabledListingTypes`, and the distinction is the one
+ * that review found being lost: `enabled` stays TRUE for `"unlisted"` (its
+ * pages must keep serving), so a tab list built from `enabledListingTypes`
+ * silently re-advertises every type an admin just unlisted. `enabled` is the
+ * right answer for a QUERY span or an authoring control; this is the right
+ * answer for anything a visitor clicks.
+ *
+ * Sits BELOW `visibleListingTypes`, which additionally drops types measured
+ * empty — use that one where a count snapshot is available, this one where
+ * the caller does its own count-based hiding (the category/brand tab bars).
+ */
+export function listedListingTypes(settings) {
+    return ALL_LISTING_TYPES.filter((t) => isListingTypeListed(t, settings));
+}
 /**
  * Should this listing type's public surface be shown at all?
  *
@@ -195,17 +281,68 @@ export function isCountedSurfaceVisible(surface, counts) {
     return n > 0;
 }
 /**
- * Visible listing types — the flag list, minus the ones measured empty.
+ * Visible listing types — the flag list, minus the ones measured empty,
+ * minus the ones set to `"unlisted"`.
  *
  * This is what nav, footer and the sitemap filter on. `enabledListingTypes`
  * above is deliberately left alone: it answers "what does this marketplace
  * sell", which `/api/products`' post-filter and the seller forms still need
- * even for a type with zero rows today.
+ * even for a type with zero rows today. `isListingSurfaceVisible` (and
+ * therefore `hiddenSurfaceRoutes`'s 404 gate) is ALSO deliberately left
+ * alone — an `"unlisted"` type keeps serving its browse route and every
+ * detail page at 200, it only stops being advertised here.
  */
 export function visibleListingTypes(settings, counts) {
-    return ALL_LISTING_TYPES.filter((t) => isListingSurfaceVisible(t, settings, counts));
+    return ALL_LISTING_TYPES.filter((t) => isListingSurfaceVisible(t, settings, counts) && isListingTypeListed(t, settings));
 }
+/**
+ * Every category type, in canonical iteration order.
+ *
+ * Declared as `Record<CategoryType, true>` rather than a plain array, same
+ * reason as `ALL_LISTING_TYPES_MAP` above (Root Cause #61): adding a member to
+ * the `CategoryType` union without adding it here is then a COMPILE error, not
+ * a silent omission. `franchise` and `character` were missing from the old
+ * hand-written array here for exactly that reason — `enabledCategoryTypes()`
+ * never included either even when enabled, which meant
+ * `BrandDetailTabs.tsx`/`CategoryDetailTabs.tsx`'s tab-visibility filter
+ * (`enabledCategoryTypes.includes(mapping.type)`) always dropped any tab
+ * mapped to `franchise`/`character`, regardless of the actual flag state.
+ */
+const ALL_CATEGORY_TYPES_MAP = {
+    category: true,
+    sublisting: true,
+    brand: true,
+    bundle: true,
+    franchise: true,
+    character: true,
+};
+export const ALL_CATEGORY_TYPES = Object.keys(ALL_CATEGORY_TYPES_MAP);
 export function enabledCategoryTypes(settings) {
-    const all = ["category", "sublisting", "brand", "bundle"];
-    return all.filter((t) => isCategoryTypeEnabled(t, settings));
+    return ALL_CATEGORY_TYPES.filter((t) => isCategoryTypeEnabled(t, settings));
+}
+/**
+ * One operational row's visibility check (1A-iii) — for the ~50+ schemas
+ * that already carry the canonical `listingType`/`categoryType` scalar
+ * CLAUDE.md's "Listing Types Reference" documents, read by a PUBLIC-facing
+ * list. Reuses `isListingTypeEnabled`/`isCategoryTypeEnabled` directly rather
+ * than adding a second tag array to a transactional record — the row already
+ * names its own type, it just needs that name checked against the live flag
+ * at the query/render layer.
+ *
+ * 🛑 Deliberately NOT for genuinely operational, non-public surfaces (orders,
+ * cart, payments, shipments, ledger, audit-log, jobs) — a buyer must keep
+ * seeing their own past order for a since-closed listing type; filtering
+ * that by the live flag would be a regression, not a fix. Call this only
+ * from a public LIST/browse read path.
+ */
+export function isGovernedRowVisible(row, settings) {
+    if (row.listingType &&
+        !isListingTypeEnabled(row.listingType, settings)) {
+        return false;
+    }
+    if (row.categoryType &&
+        !isCategoryTypeEnabled(row.categoryType, settings)) {
+        return false;
+    }
+    return true;
 }