@mohasinac/appkit 4.52.5 → 4.53.1

package/dist/_internal/shared/features/sticker-trace/types.d.ts

@@ -0,0 +1,197 @@
+/** Decoded pixels. Always RGBA8, row-major, tightly packed. */
+export interface DecodedRaster {
+    readonly width: number;
+    readonly height: number;
+    /** length === width * height * 4 */
+    readonly data: Uint8Array;
+    /**
+     * Scan resolution, when the source declared one AND an operator confirmed it.
+     *
+     * Absent is a real answer and must stay representable: five of the nine
+     * reference scans declare 72 or 96 dpi, which is a default the encoder wrote
+     * rather than a measurement. Millimetre output is WITHHELD when this is
+     * undefined — a fabricated mm figure on a cut file is a physical production
+     * error, which is a different class of wrong from a missing number.
+     */
+    readonly dpi?: number;
+}
+export interface EncodedImage {
+    readonly bytes: Uint8Array;
+    readonly contentType: string;
+}
+export interface Rect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+/** One cubic Bézier segment; the start point is the previous segment's end. */
+export interface CubicSegment {
+    readonly c1: Point;
+    readonly c2: Point;
+    readonly to: Point;
+}
+/**
+ * One closed outline. Kiss-cut sheets cut the outer boundary only — interior
+ * holes are never cut, or the sticker falls apart on the backing — so a part
+ * carries exactly one path and `segments` always closes back to `start`.
+ */
+export interface CutPath {
+    readonly start: Point;
+    readonly segments: readonly CubicSegment[];
+}
+/**
+ * The pipeline, in order. A failure reports the stage it died in, which is the
+ * difference between "it broke" and "the ridge detector found nothing on a
+ * halftone scan" — so the union is shared by the runner, the progress channel
+ * and the retry panel rather than restated in each.
+ */
+export declare const TRACE_STAGES: readonly ["decode", "prefilter", "ridge", "quantise", "fuse", "flood", "segment", "cluster", "geometry", "parts", "exports"];
+export type TraceStage = (typeof TRACE_STAGES)[number];
+/**
+ * `paper` — stickers sit on bare backing; the sheet border is background.
+ * `art`   — the whole sheet is printed and the only signal is the cut line.
+ * `auto`  — decide from the border band's colour spread (see trace/paper).
+ *
+ * Several real sheets are BOTH (black-dranzer is paper on the left, solid red
+ * and blue panels on the right), which is why this selects an emphasis rather
+ * than switching algorithms: the ridge pass runs regardless, and this only
+ * weights how much the paper-flood is trusted.
+ */
+export type ScanType = "auto" | "paper" | "art";
+export type PrecisionTier = "draft" | "standard" | "precise" | "max";
+export type PrefilterKind = "none" | "median" | "bilateral";
+/**
+ * Grouped BY STAGE, and that grouping is load-bearing rather than cosmetic: a
+ * resumed run may only skip stages whose parameters did not change. Without the
+ * grouping, "resume from `parts` with a different ridge threshold" yields a run
+ * whose stored artifacts were produced under different parameters than the run
+ * records, and nothing anywhere contradicts it.
+ */
+export interface TraceParams {
+    readonly tier: PrecisionTier;
+    readonly scanType: ScanType;
+    /** decode */
+    readonly workingLongEdge: number;
+    readonly dpi?: number;
+    /** prefilter */
+    readonly prefilter: PrefilterKind;
+    readonly prefilterRadius: number;
+    /** ridge */
+    readonly ridgeHysteresisLow: number;
+    readonly ridgeHysteresisHigh: number;
+    readonly ridgeKernelScale: number;
+    /** quantise — the second detector channel; see trace/quantise */
+    readonly quantiseEnabled: boolean;
+    readonly quantiseColours: number;
+    readonly quantiseWeight: number;
+    /** flood */
+    readonly paperTolerance: number;
+    readonly seedBandPx: number;
+    /** segment */
+    readonly minPartAreaMm2: number;
+    readonly maxParts: number;
+    readonly bridgeMm: number;
+    /**
+     * Art sheets only. A region boundary below this multiple of the sheet's
+     * MEDIAN boundary strength is treated as printing rather than a cut, and the
+     * two regions merge. See trace/merge for why this exists at all.
+     */
+    readonly mergeStrengthFactor: number;
+    /** geometry */
+    readonly smoothMm: number;
+    readonly borderMm: number;
+    readonly bleedMm: number;
+    readonly simplifyMm: number;
+    readonly cleanMm: number;
+    /** cluster */
+    readonly clusterGapMm: number;
+}
+export interface PartGeometry {
+    /** 1-based, stable within a run; what the admin renames and references. */
+    readonly ordinal: number;
+    /** Which physical sheet this part belongs to, when one scan holds several. */
+    readonly groupIndex: number;
+    readonly bboxPx: Rect;
+    readonly areaPx: number;
+    /** Null whenever DPI is unknown — never a guess. */
+    readonly bboxMm: Rect | null;
+    readonly areaMm2: number | null;
+    /**
+     * Narrowest internal width, in mm when DPI is known. Cricut's minimum
+     * reliable detail is 0.25in (6mm); a part with a neck below that tears rather
+     * than cuts, so the exporter needs this to warn before a sheet is wasted.
+     */
+    readonly minFeatureMm: number | null;
+    readonly path: CutPath;
+}
+/**
+ * One physical sheet within a scan. A 4948x6955 scan can hold several, and
+ * grouping them by large border gaps is what makes the part list navigable
+ * rather than one run of sixty.
+ */
+export interface SheetCluster {
+    readonly index: number;
+    readonly bboxPx: Rect;
+    readonly partOrdinals: readonly number[];
+}
+/**
+ * Reported whether or not the trace succeeded, because the numbers that explain
+ * a BAD result are the same ones that explain a good one. `ridgeCoverage` near
+ * zero on an `art` scan means the detector found nothing — which is a different
+ * remedy from `droppedBelowMinArea` in the hundreds, which means it found noise.
+ */
+export interface TraceDiagnostics {
+    readonly workingSize: Rect;
+    readonly paperColour: readonly [number, number, number] | null;
+    readonly ridgeCoverage: number;
+    readonly quantiseCoverage: number;
+    readonly fusedCoverage: number;
+    readonly componentsFound: number;
+    readonly droppedBelowMinArea: number;
+    /**
+     * Components covering more than MAX_PART_FRACTION of the raster.
+     *
+     * 🛑 Named for what it counts. It was `droppedTouchingBorder`, which told a
+     * reader diagnosing a zero-part scan that a sticker had run off the edge —
+     * a different and wrong story. A sheet-sized component means the flood never
+     * got IN, and that is the one thing worth knowing at that moment.
+     */
+    readonly droppedSheetSized: number;
+    /**
+     * Fraction of the raster the paper path could flood through.
+     *
+     * The paper model needs real background; `isAvailable`-style negation has
+     * nothing to work with when there is none. Measured across this corpus at
+     * `standard`, the three paper scans that segment correctly sit at 27.7%,
+     * 51.3% and 74.2%, and the one that returns zero parts sits at **7.8%** — so
+     * this is the statistic that separates "this sheet has no stickers" from
+     * "this model cannot read this scan", which otherwise look identical.
+     *
+     * 1 on an art scan, where the question does not arise.
+     */
+    readonly backgroundCoverage: number;
+    readonly bridgedComponents: number;
+    /**
+     * Reserved. Art-background sheets WERE unsupported — see the git history for
+     * the four approaches that failed and why — and are now handled by the
+     * Hessian line filter plus the region merge. Kept as a field rather than
+     * deleted because the art path is the one whose accuracy depends on a tuned
+     * constant (mergeStrengthFactor), so a future sheet that defeats it needs a
+     * way to say so without a schema change.
+     */
+    readonly artBackgroundUnsupported: boolean;
+}
+export interface TraceResult {
+    readonly parts: readonly PartGeometry[];
+    readonly clusters: readonly SheetCluster[];
+    readonly diagnostics: TraceDiagnostics;
+    /** Pixels per millimetre, or null when DPI is unknown. */
+    readonly pxPerMm: number | null;
+    /** Scale from working-raster pixels back to the source image. */
+    readonly sourceScale: number;
+}

package/dist/_internal/shared/features/sticker-trace/types.js

@@ -0,0 +1,49 @@
+/*
+ * WHY: A scanned sticker sheet has to become cut-ready geometry, and the same
+ *      algorithm has to run in two places — a browser tuning it live, and a
+ *      Firebase Function rendering it at full resolution. Two implementations
+ *      would drift (CLAUDE.md Root Cause #59/#73), so there is exactly one, and
+ *      these are the shapes it speaks in.
+ * WHAT: Every type the tracing core exchanges with its callers. Deliberately
+ *       free of any image-codec, Firestore or DOM type: the core takes decoded
+ *       pixels and returns geometry, and knows nothing about where either came
+ *       from.
+ *
+ * Coordinates are a constant source of error here, so the rule is stated once:
+ * every geometric value in this module is in WORKING-RASTER PIXELS unless its
+ * name ends in `Mm`. The working raster is a downscale of the source (see
+ * config.WORKING_LONG_EDGE), so a caller rendering at full resolution scales by
+ * `source.width / raster.width`. Carrying vectors rather than masks is what
+ * makes that rescale exact.
+ *
+ * EXPORTS:
+ *   DecodedRaster, EncodedImage, Rect, Point, CubicSegment, CutPath,
+ *   TraceStage, TRACE_STAGES, ScanType, PrecisionTier, PrefilterKind,
+ *   TraceParams, PartGeometry, SheetCluster, TraceResult, TraceDiagnostics
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:trace/*,math/*,export/*,canvas-codec,sharp-codec,run
+ * @tag sideEffects:none
+ */
+/**
+ * The pipeline, in order. A failure reports the stage it died in, which is the
+ * difference between "it broke" and "the ridge detector found nothing on a
+ * halftone scan" — so the union is shared by the runner, the progress channel
+ * and the retry panel rather than restated in each.
+ */
+export const TRACE_STAGES = [
+    "decode",
+    "prefilter",
+    "ridge",
+    "quantise",
+    "fuse",
+    "flood",
+    "segment",
+    "cluster",
+    "geometry",
+    "parts",
+    "exports",
+];

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

@@ -23,6 +23,7 @@
  */
 import { LISTING_TYPE_CAPABILITIES } from "./capabilities";
 import { type AvailabilityRow, type UnavailableClause } from "./availability";
+import type { IconKey } from "../../../ui/icons/icon-registry";
 import type { ListingType } from "../../../features/products/types/index";
 import type { SortOption } from "../../../features/products/constants/sieve";
 import { type AvailabilityFilter } from "../../../constants/field-names";
@@ -107,6 +108,40 @@ 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.
+     *
+     * 🛑 REQUIRED, like `inGeneralCatalogue` and for the same reason: a tenth
+     * listing type must not compile until someone has answered what it looks
+     * like. An optional field would be silently omitted and that type would be
+     * the one unlabelled row in every picker — the gap being invisible is
+     * exactly the failure the required fields on this interface exist to stop.
+     */
+    iconKey: IconKey;
     /**
      * Which "Show X" default this type's browse surfaces apply. Since 2026-08-24
      * this drives the LABEL of the availability tab bar's middle tab

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,8 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    canJoinProductGroup: boolean;
+    iconKey: "art";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

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

@@ -22,6 +22,9 @@ 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
     // stock-only rules are the whole story for this type.

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

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

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

@@ -22,6 +22,9 @@ 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.
     hideDefault: "ended",

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,8 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    canJoinProductGroup: boolean;
+    iconKey: "deals";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

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

@@ -21,6 +21,9 @@ 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
     // stock-only rules are the whole story for this type.

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

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

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

@@ -34,6 +34,9 @@ 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
     // with a drained pool and non-zero stock. The pool count is authoritative.

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

@@ -34,6 +34,13 @@ interface FeatureFlagSnapshot {
 export declare function isListingTypeEnabled(type: ListingType, settings: FeatureFlagSnapshot | null | undefined): boolean;
 export declare function isCategoryTypeEnabled(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
+ * real member of the union. Backed by the same `Record<ListingType, true>` as
+ * `ALL_LISTING_TYPES`, so it cannot fall behind the union the way a
+ * hand-written list would (Root Cause #61).
+ */
+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[];
 export declare function enabledCategoryTypes(settings: FeatureFlagSnapshot | null | undefined): CategoryType[];

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,
@@ -54,6 +55,15 @@ const ALL_LISTING_TYPES_MAP = {
     stickers: true,
 };
 export const ALL_LISTING_TYPES = Object.keys(ALL_LISTING_TYPES_MAP);
+/**
+ * Narrow an untrusted string — a `?listingType=` param, a form value — to a
+ * real member of the union. Backed by the same `Record<ListingType, true>` as
+ * `ALL_LISTING_TYPES`, so it cannot fall behind the union the way a
+ * hand-written list would (Root Cause #61).
+ */
+export function isListingType(value) {
+    return typeof value === "string" && value in ALL_LISTING_TYPES_MAP;
+}
 /** Pull the full list of enabled listing types in canonical iteration order. */
 export function enabledListingTypes(settings) {
     return ALL_LISTING_TYPES.filter((t) => isListingTypeEnabled(t, settings));

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

@@ -18,6 +18,8 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    canJoinProductGroup: boolean;
+    iconKey: "live";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

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

@@ -21,6 +21,9 @@ 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
     // stock-only rules are the whole story for this type.

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

@@ -18,6 +18,8 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    canJoinProductGroup: boolean;
+    iconKey: "preOrder";
     hideDefault: "closed";
     isAvailable: (row: AvailabilityRow) => boolean;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

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

@@ -21,6 +21,9 @@ 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
     // passes — a shipped-soon pre-order is still orderable. `preOrderClosed`

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

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

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

@@ -21,6 +21,9 @@ 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
     // unsold (the seller ends it early, or the reveal window lapses), and it can