@mohasinac/appkit 4.13.1 → 4.14.0

package/dist/_internal/shared/history/types.js

@@ -0,0 +1,6 @@
+/**
+ * Cap for any history array. Matches `HISTORY_MAX`'s reasoning: an unbounded
+ * array on a hot document inflates every read of that document (Rule #6), and
+ * an order that changes status more than this has a different problem.
+ */
+export const STATUS_HISTORY_MAX = 50;

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

@@ -22,8 +22,10 @@
  * that doesn't cover the full union.
  */
 import { LISTING_TYPE_CAPABILITIES } from "./capabilities";
+import { type AvailabilityRow, type UnavailableClause } from "./availability";
 import type { ListingType } from "../../../features/products/types/index";
 import type { SortOption } from "../../../features/products/constants/sieve";
+import { type AvailabilityFilter } from "../../../constants/field-names";
 /**
  * Which "Show X" quick-filter a listing type's browse surfaces default to
  * hiding. Drives both the toolbar toggle label and the SSR default filter,
@@ -78,8 +80,29 @@ export interface ListingTypePlugin {
      * /products when exactly this type is selected.
      */
     browseRoute: string | null;
-    /** Which "Show X" default this type's browse surfaces apply. */
+    /**
+     * 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
+     * (`availabilityTabsFor`) rather than a toggle pill's wording.
+     */
     hideDefault: ListingHideDefault;
+    /**
+     * Is this row still buyable / biddable / enterable? Type-specific checks
+     * ONLY — `baseAvailable` (isSold / availableQuantity / stockQuantity) is
+     * applied to every type by `isListingRowAvailable` before this runs, so a
+     * type with no extra rule returns `true`.
+     *
+     * Must stay pure and client-safe: the same predicate runs inside the SSR
+     * query, the homepage fetch and the related-items carousel.
+     */
+    isAvailable: (row: AvailabilityRow, now: Date) => boolean;
+    /**
+     * The query half of the same question — see `UnavailableClause`. Used to
+     * front-load the "Sold & Ended" scope, which is sparse and therefore
+     * expressible as an OR of equalities, unlike "available", which is dense and
+     * negation-shaped and stays an in-memory predicate.
+     */
+    unavailableClauses: readonly UnavailableClause[];
     /** Sort set offered on admin/seller dashboards for this type. */
     sortOptions: readonly SortOption[];
     /** Narrower sort set offered on public browse surfaces for this type. */
@@ -124,4 +147,34 @@ export declare function commonSortOptionsFor(types: readonly ListingType[], vari
  * so this returns every distinct default across the set.
  */
 export declare function hideDefaultsFor(types: readonly ListingType[]): ListingHideDefault[];
+export interface AvailabilityTab {
+    id: AvailabilityFilter;
+    label: string;
+}
+/**
+ * The three-tab availability bar for a set of listing types.
+ *
+ * The middle label is derived, not a constant: `/auctions` reads "Ended",
+ * `/art` reads "Sold", and `/products` — which spans both kinds — reads
+ * "Sold & Ended". Ordering is fixed rather than set-iteration order so the
+ * label can never flip to "Ended & Sold" between renders.
+ */
+export declare function availabilityTabsFor(types: readonly ListingType[]): AvailabilityTab[];
+/**
+ * THE definition of "this listing is still available", shared by the listing
+ * query, the homepage fetch and the related-items carousel. Before this there
+ * were four partial versions of it and they disagreed — see the header of
+ * `./availability`.
+ *
+ * An unrecognised `listingType` falls back to `standard` rather than throwing:
+ * these rows come from Firestore and a bad value must degrade to the base
+ * checks, not blank the page.
+ */
+export declare function isListingRowAvailable(row: AvailabilityRow, now: Date): boolean;
+/**
+ * Every distinct `UnavailableClause` across a set of listing types, deduped by
+ * field+op+value. `/products` (all nine types) collapses to five clauses, so
+ * the "Sold & Ended" scope costs five bounded queries, not nine.
+ */
+export declare function unavailableClausesFor(types: readonly ListingType[]): UnavailableClause[];
 export { LISTING_TYPE_CAPABILITIES };

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

@@ -33,6 +33,8 @@ import * as live from "./live/config";
 import * as art from "./art/config";
 import * as stickers from "./stickers/config";
 import { LISTING_TYPE_CAPABILITIES } from "./capabilities";
+import { baseAvailable, } from "./availability";
+import { AVAILABILITY_VALUES, } from "../../../constants/field-names";
 // SB-UNI-D — bundle entry removed; bundles are a categoryType, not a listingType.
 // SB-UNI-F 2026-05-13 — classified / digital-code / live added.
 // EMI/art-stickers session — art / stickers added.
@@ -112,6 +114,71 @@ export function hideDefaultsFor(types) {
         seen.add(LISTING_TYPE_REGISTRY[type].hideDefault);
     return [...seen];
 }
+// ---------------------------------------------------------------------------
+// Availability scope
+// ---------------------------------------------------------------------------
+/**
+ * The user-facing noun for each hide-default. "ended" and "closed" are one
+ * query mechanic and one word to a buyer — an auction that ended and a prize
+ * draw that closed are both simply over.
+ *
+ * `Record<ListingHideDefault, …>` on purpose: adding a fourth hide-default is
+ * then a compile error rather than a tab that silently renders `undefined`.
+ */
+const HIDE_DEFAULT_NOUN = {
+    sold: "Sold",
+    ended: "Ended",
+    closed: "Ended",
+};
+/**
+ * The three-tab availability bar for a set of listing types.
+ *
+ * The middle label is derived, not a constant: `/auctions` reads "Ended",
+ * `/art` reads "Sold", and `/products` — which spans both kinds — reads
+ * "Sold & Ended". Ordering is fixed rather than set-iteration order so the
+ * label can never flip to "Ended & Sold" between renders.
+ */
+export function availabilityTabsFor(types) {
+    const nouns = new Set((types.length > 0 ? types : Object.keys(LISTING_TYPE_REGISTRY)).map((t) => HIDE_DEFAULT_NOUN[LISTING_TYPE_REGISTRY[t].hideDefault]));
+    const unavailableLabel = ["Sold", "Ended"].filter((n) => nouns.has(n)).join(" & ") || "Sold";
+    return [
+        { id: AVAILABILITY_VALUES.AVAILABLE, label: "Available" },
+        { id: AVAILABILITY_VALUES.UNAVAILABLE, label: unavailableLabel },
+        { id: AVAILABILITY_VALUES.ALL, label: "All" },
+    ];
+}
+/**
+ * THE definition of "this listing is still available", shared by the listing
+ * query, the homepage fetch and the related-items carousel. Before this there
+ * were four partial versions of it and they disagreed — see the header of
+ * `./availability`.
+ *
+ * An unrecognised `listingType` falls back to `standard` rather than throwing:
+ * these rows come from Firestore and a bad value must degrade to the base
+ * checks, not blank the page.
+ */
+export function isListingRowAvailable(row, now) {
+    if (!baseAvailable(row))
+        return false;
+    const raw = row.listingType;
+    const type = typeof raw === "string" && raw in LISTING_TYPE_REGISTRY ? raw : "standard";
+    return LISTING_TYPE_REGISTRY[type].isAvailable(row, now);
+}
+/**
+ * Every distinct `UnavailableClause` across a set of listing types, deduped by
+ * field+op+value. `/products` (all nine types) collapses to five clauses, so
+ * the "Sold & Ended" scope costs five bounded queries, not nine.
+ */
+export function unavailableClausesFor(types) {
+    const effective = types.length > 0 ? types : Object.keys(LISTING_TYPE_REGISTRY);
+    const seen = new Map();
+    for (const type of effective) {
+        for (const clause of LISTING_TYPE_REGISTRY[type].unavailableClauses) {
+            seen.set(`${clause.field}|${clause.op}|${String(clause.value)}`, clause);
+        }
+    }
+    return [...seen.values()];
+}
 // Re-export the capability map so consumers can pull both surfaces from
 // the same module path.
 export { LISTING_TYPE_CAPABILITIES };

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

@@ -1,3 +1,4 @@
+import { alwaysAvailable } from "../availability";
 export declare const LISTING_TYPE: "art";
 export declare const capability: import("../capabilities").ListingTypeCapability;
 export declare const config: {
@@ -17,6 +18,8 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     hideDefault: "sold";
+    isAvailable: typeof alwaysAvailable;
+    unavailableClauses: readonly import("../availability").UnavailableClause[];
     sortOptions: readonly [{
         readonly value: string;
         readonly label: "Newest First";

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

@@ -1,4 +1,5 @@
 import { LISTING_TYPE_CAPABILITIES } from "../capabilities";
+import { alwaysAvailable, STOCK_ONLY_UNAVAILABLE_CLAUSES, } from "../availability";
 import { ROUTES } from "../../../../next/routing/route-map";
 import { STANDARD_SORT_OPTIONS, STANDARD_PUBLIC_SORT_OPTIONS, } from "../../../../features/products/constants/sieve";
 export const LISTING_TYPE = "art";
@@ -20,6 +21,10 @@ export const config = {
     // dedicated browse surface even though detailRoute points at /products.
     browseRoute: String(ROUTES.PUBLIC.ART),
     hideDefault: "sold",
+    // Runs out rather than ending — no time dimension, so the shared
+    // stock-only rules are the whole story for this type.
+    isAvailable: alwaysAvailable,
+    unavailableClauses: STOCK_ONLY_UNAVAILABLE_CLAUSES,
     sortOptions: STANDARD_SORT_OPTIONS,
     publicSortOptions: STANDARD_PUBLIC_SORT_OPTIONS,
     extraFacetKeys: [],

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

@@ -1,3 +1,4 @@
+import { type AvailabilityRow } from "../availability";
 export declare const LISTING_TYPE: "auction";
 export declare const capability: import("../capabilities").ListingTypeCapability;
 export declare const config: {
@@ -17,6 +18,18 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     hideDefault: "ended";
+    isAvailable: (row: AvailabilityRow, now: Date) => boolean;
+    unavailableClauses: ({
+        field: "auctionEndDate";
+        op: "lt";
+        value: "NOW";
+        sortField: "auctionEndDate";
+    } | {
+        field: "isSold";
+        op: "eq";
+        value: boolean;
+        sortField?: undefined;
+    })[];
     sortOptions: readonly [{
         readonly value: string;
         readonly label: "Ending Soon";

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

@@ -1,6 +1,8 @@
 import { LISTING_TYPE_CAPABILITIES } from "../capabilities";
+import { toDate } from "../availability";
 import { ROUTES } from "../../../../next/routing/route-map";
 import { TABLE_KEYS } from "../../../../constants/table-keys";
+import { PRODUCT_FIELDS } from "../../../../constants/field-names";
 import { AUCTION_SORT_OPTIONS, AUCTION_PUBLIC_SORT_OPTIONS, } from "../../../../features/products/constants/sieve";
 export const LISTING_TYPE = "auction";
 export const capability = LISTING_TYPE_CAPABILITIES.auction;
@@ -20,6 +22,25 @@ export const config = {
     // 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",
+    // There is no `auctionStatus` field — "ended" is purely the end date having
+    // passed. An auction 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.AUCTION_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 auctions" archive ("Recently Ended").
+        {
+            field: PRODUCT_FIELDS.AUCTION_END_DATE,
+            op: "lt",
+            value: "NOW",
+            sortField: PRODUCT_FIELDS.AUCTION_END_DATE,
+        },
+        { field: PRODUCT_FIELDS.IS_SOLD, op: "eq", value: true },
+    ],
     sortOptions: AUCTION_SORT_OPTIONS,
     publicSortOptions: AUCTION_PUBLIC_SORT_OPTIONS,
     extraFacetKeys: [

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

@@ -0,0 +1,79 @@
+import type { FirestoreValue } from "../../../schemas/types";
+/**
+ * A product row as it reaches a predicate.
+ *
+ * Deliberately the project’s sanctioned loose Firestore-row alias rather than
+ * `ProductDocument`: the same row arrives here in three shapes — a Firestore
+ * document (Date / Timestamp fields), an already-serialised payload from the
+ * colocated `listingProcessor` Function (ISO strings), and JSON from
+ * `/api/products`. Narrowing to any one of them would just push a cast to
+ * every call site.
+ */
+export type AvailabilityRow = Record<string, FirestoreValue>;
+/**
+ * Everything a timestamp field can be by the time it reaches `toDate`. The
+ * `{ toDate() }` arm is a Firestore `Timestamp`, which cannot be imported
+ * here — this module is client-safe and firebase-admin is not.
+ */
+export type DateLike = FirestoreValue | {
+    toDate: () => Date;
+};
+/**
+ * Firestore Timestamp | Date | ISO string | epoch millis → Date, or null when
+ * the value is absent or unparseable. Firestore hands back a `Timestamp` with
+ * a `toDate()` method server-side but a plain ISO string once serialised, and
+ * a predicate that handles only one of those silently returns the wrong answer
+ * on the other runtime.
+ */
+export declare function toDate(value: DateLike): Date | null;
+/** Read a numeric field, or `null` when absent/non-numeric. */
+export declare function num(value: DateLike): number | null;
+/**
+ * The checks every listing type shares, regardless of `listingType`.
+ *
+ * Note what is NOT here: `status`. Publication state (draft / in_review /
+ * archived) is a different axis from availability — an archived listing is
+ * hidden from the public entirely, while a sold one is still browsable in the
+ * "Sold & Ended" scope. Conflating them is what made `isValidRelatedItem`
+ * test for a `status: "sold"` value that has never existed.
+ *
+ * A field that is absent is treated as "not a reason to hide" — most rows
+ * carry `isSold: false` and a real quantity, but older documents predate both
+ * and must not vanish from the default scope.
+ */
+export declare function baseAvailable(row: AvailabilityRow): boolean;
+/**
+ * Whether a row may be shown on a public surface at all. Separate from
+ * availability on purpose — see `baseAvailable`.
+ */
+export declare function isPubliclyVisible(row: AvailabilityRow): boolean;
+/**
+ * The Firestore-expressible half of "this row is UNAVAILABLE".
+ *
+ * Every entry must be an EQUALITY, or an inequality that names its own
+ * `sortField` — because Firestore implicitly appends an inequality's field to
+ * the `orderBy`, so pairing one with an unrelated sort demands a composite
+ * index in an order nobody declares and fails with FAILED_PRECONDITION
+ * (Recurrent Root Cause #59). Equalities carry no such constraint, which is
+ * what makes the "Sold & Ended" fan-out safe on a mixed type selection.
+ */
+export interface UnavailableClause {
+    field: string;
+    op: "eq" | "lt";
+    /** `"NOW"` is substituted with the query's timestamp at build time. */
+    value: string | number | boolean | "NOW";
+    /** Required when `op !== "eq"` — the query MUST order by this field. */
+    sortField?: string;
+}
+/**
+ * For types whose only end-state is running out: standard, classified, live,
+ * art, stickers. Shared rather than copy-pasted into five plugin configs,
+ * which is exactly the duplication the registry exists to prevent.
+ */
+export declare const STOCK_ONLY_UNAVAILABLE_CLAUSES: readonly UnavailableClause[];
+/**
+ * `isAvailable` for a type with no rule beyond `baseAvailable`. Named rather
+ * than an inline `() => true` so the five configs that use it read as
+ * deliberately sharing one decision, not as five independent stubs.
+ */
+export declare function alwaysAvailable(): boolean;

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

@@ -0,0 +1,104 @@
+/*
+ * WHY: There was no single definition of "this listing is still available".
+ *      The closest thing was a private `isValidRelatedItem()` in
+ *      `_internal/server/features/products/data.ts`, reachable only from the
+ *      related-items carousel and carrying three bugs: it read
+ *      `row.codesAvailable` at the top level when the schema nests it under
+ *      `digitalCode.codesAvailable`; it filtered on `status` values
+ *      ("sold", "out_of_stock", "discontinued") that are not members of the
+ *      real `ProductStatus` union; and it had no branch for classified / live
+ *      / art / stickers. Meanwhile the listing pages expressed the same idea a
+ *      fourth way (an `inStock` boolean plus a `dateFrom` cutoff) and the
+ *      homepage expressed it not at all — which is why the "Live Auctions"
+ *      strip rendered the most-expired lots first.
+ *
+ * WHAT: The type-agnostic half of the availability predicate. The per-type
+ *       half lives on each listing-type plugin as `isAvailable`; the two are
+ *       combined by `isListingRowAvailable()` in `./_registry`.
+ *
+ * EXPORTS: AvailabilityRow, UnavailableClause, toDate, num, baseAvailable,
+ *          isPubliclyVisible, alwaysAvailable, STOCK_ONLY_UNAVAILABLE_CLAUSES
+ *
+ * @tag domain:products
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:_registry,list-public,data,PrizeDrawsSection
+ * @tag sideEffects:none
+ */
+import { PRODUCT_FIELDS } from "../../../constants/field-names";
+/**
+ * Firestore Timestamp | Date | ISO string | epoch millis → Date, or null when
+ * the value is absent or unparseable. Firestore hands back a `Timestamp` with
+ * a `toDate()` method server-side but a plain ISO string once serialised, and
+ * a predicate that handles only one of those silently returns the wrong answer
+ * on the other runtime.
+ */
+export function toDate(value) {
+    if (!value)
+        return null;
+    if (value instanceof Date)
+        return Number.isNaN(value.getTime()) ? null : value;
+    if (typeof value === "object" && typeof value.toDate === "function") {
+        const converted = value.toDate();
+        return converted instanceof Date && !Number.isNaN(converted.getTime()) ? converted : null;
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? null : parsed;
+    }
+    return null;
+}
+/** Read a numeric field, or `null` when absent/non-numeric. */
+export function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/**
+ * The checks every listing type shares, regardless of `listingType`.
+ *
+ * Note what is NOT here: `status`. Publication state (draft / in_review /
+ * archived) is a different axis from availability — an archived listing is
+ * hidden from the public entirely, while a sold one is still browsable in the
+ * "Sold & Ended" scope. Conflating them is what made `isValidRelatedItem`
+ * test for a `status: "sold"` value that has never existed.
+ *
+ * A field that is absent is treated as "not a reason to hide" — most rows
+ * carry `isSold: false` and a real quantity, but older documents predate both
+ * and must not vanish from the default scope.
+ */
+export function baseAvailable(row) {
+    if (row[PRODUCT_FIELDS.IS_SOLD] === true)
+        return false;
+    const available = num(row[PRODUCT_FIELDS.AVAILABLE_QUANTITY]);
+    if (available !== null && available <= 0)
+        return false;
+    const stock = num(row[PRODUCT_FIELDS.STOCK_QUANTITY]);
+    if (stock !== null && stock <= 0)
+        return false;
+    return true;
+}
+/**
+ * Whether a row may be shown on a public surface at all. Separate from
+ * availability on purpose — see `baseAvailable`.
+ */
+export function isPubliclyVisible(row) {
+    const status = row[PRODUCT_FIELDS.STATUS];
+    return status === undefined || status === PRODUCT_FIELDS.STATUS_VALUES.PUBLISHED;
+}
+/**
+ * For types whose only end-state is running out: standard, classified, live,
+ * art, stickers. Shared rather than copy-pasted into five plugin configs,
+ * which is exactly the duplication the registry exists to prevent.
+ */
+export const STOCK_ONLY_UNAVAILABLE_CLAUSES = [
+    { field: PRODUCT_FIELDS.AVAILABLE_QUANTITY, op: "eq", value: 0 },
+    { field: PRODUCT_FIELDS.IS_SOLD, op: "eq", value: true },
+];
+/**
+ * `isAvailable` for a type with no rule beyond `baseAvailable`. Named rather
+ * than an inline `() => true` so the five configs that use it read as
+ * deliberately sharing one decision, not as five independent stubs.
+ */
+export function alwaysAvailable() {
+    return true;
+}

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

@@ -24,6 +24,20 @@ export interface ListingTypeCapability {
     requiresJurisdictionCheck: boolean;
     /** Listing fulfills immediately on purchase (no shipping label flow). */
     hasInstantFulfillment: boolean;
+    /**
+     * Buyers can negotiate the price via the Make-an-Offer flow.
+     *
+     * A per-listing `allowOffers` flag is still required on top of this — the
+     * capability says the TYPE can support offers at all, the flag says this
+     * particular seller opted in. `makeOffer` checks both.
+     *
+     * False wherever a negotiated price would collide with the type's own pricing
+     * mechanism: an auction already has bidding, a prize-draw sells fixed-price
+     * entries, a digital code is a fungible pool item, a pre-order is a deposit
+     * against a future price, and a live item is jurisdiction-gated with a
+     * verified vendor on the hook for it.
+     */
+    canMakeOffer: boolean;
 }
 export declare const LISTING_TYPE_CAPABILITIES: Record<ListingType, ListingTypeCapability>;
 export declare function capabilityFor(type: ListingType): ListingTypeCapability;
@@ -33,6 +47,7 @@ export declare function supportsShipping(type: ListingType): boolean;
 export declare function requiresVendorVerified(type: ListingType): boolean;
 export declare function requiresJurisdictionCheck(type: ListingType): boolean;
 export declare function hasInstantFulfillment(type: ListingType): boolean;
+export declare function canMakeOffer(type: ListingType): boolean;
 /**
  * Exhaustive-switch helper. Use in `switch (type) { case ...: default: assertNever(type); }`
  * so adding a new `ListingType` member is a TS error at every consumer

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

@@ -18,6 +18,7 @@ export const LISTING_TYPE_CAPABILITIES = {
         requiresVendorVerified: false,
         requiresJurisdictionCheck: false,
         hasInstantFulfillment: false,
+        canMakeOffer: true, // the ordinary negotiable listing
     },
     auction: {
         canAddToCart: false,
@@ -26,6 +27,7 @@ export const LISTING_TYPE_CAPABILITIES = {
         requiresVendorVerified: false,
         requiresJurisdictionCheck: false,
         hasInstantFulfillment: false,
+        canMakeOffer: false, // bidding IS the price mechanism
     },
     "pre-order": {
         canAddToCart: true,
@@ -34,6 +36,7 @@ export const LISTING_TYPE_CAPABILITIES = {
         requiresVendorVerified: false,
         requiresJurisdictionCheck: false,
         hasInstantFulfillment: false,
+        canMakeOffer: false, // deposit against a future price, not a price to haggle
     },
     "prize-draw": {
         canAddToCart: true,
@@ -42,6 +45,7 @@ export const LISTING_TYPE_CAPABILITIES = {
         requiresVendorVerified: false,
         requiresJurisdictionCheck: false,
         hasInstantFulfillment: false,
+        canMakeOffer: false, // fixed-price entries; a discounted entry breaks the draw's economics
     },
     // SB-UNI-F 2026-05-13 — Phase 2 union extension.
     classified: {
@@ -51,6 +55,7 @@ export const LISTING_TYPE_CAPABILITIES = {
         requiresVendorVerified: false,
         requiresJurisdictionCheck: false,
         hasInstantFulfillment: false,
+        canMakeOffer: true, // haggling is the norm here — see the `negotiable` flag
     },
     "digital-code": {
         canAddToCart: true,
@@ -59,6 +64,7 @@ export const LISTING_TYPE_CAPABILITIES = {
         requiresVendorVerified: false,
         requiresJurisdictionCheck: false,
         hasInstantFulfillment: true, // atomic code claim at order paid
+        canMakeOffer: false, // fungible pool item, priced per code
     },
     live: {
         canAddToCart: true, // but jurisdictionAllowed must include buyer's state
@@ -67,6 +73,7 @@ export const LISTING_TYPE_CAPABILITIES = {
         requiresVendorVerified: true,
         requiresJurisdictionCheck: true,
         hasInstantFulfillment: false,
+        canMakeOffer: false, // jurisdiction-gated with a verified vendor accountable for the price
     },
     // Art/stickers session — printed-only physical goods, standard-like checkout.
     art: {
@@ -76,6 +83,7 @@ export const LISTING_TYPE_CAPABILITIES = {
         requiresVendorVerified: false,
         requiresJurisdictionCheck: false,
         hasInstantFulfillment: false,
+        canMakeOffer: true, // printed goods, standard-like
     },
     stickers: {
         canAddToCart: true,
@@ -84,6 +92,7 @@ export const LISTING_TYPE_CAPABILITIES = {
         requiresVendorVerified: false,
         requiresJurisdictionCheck: false,
         hasInstantFulfillment: false,
+        canMakeOffer: true, // printed goods, standard-like
     },
 };
 export function capabilityFor(type) {
@@ -107,6 +116,9 @@ export function requiresJurisdictionCheck(type) {
 export function hasInstantFulfillment(type) {
     return LISTING_TYPE_CAPABILITIES[type].hasInstantFulfillment;
 }
+export function canMakeOffer(type) {
+    return LISTING_TYPE_CAPABILITIES[type].canMakeOffer;
+}
 /**
  * Exhaustive-switch helper. Use in `switch (type) { case ...: default: assertNever(type); }`
  * so adding a new `ListingType` member is a TS error at every consumer

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

@@ -1,3 +1,4 @@
+import { alwaysAvailable } from "../availability";
 export declare const LISTING_TYPE: "classified";
 export declare const capability: import("../capabilities").ListingTypeCapability;
 export declare const config: {
@@ -17,6 +18,8 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     hideDefault: "sold";
+    isAvailable: typeof alwaysAvailable;
+    unavailableClauses: readonly import("../availability").UnavailableClause[];
     sortOptions: readonly [{
         readonly value: string;
         readonly label: "Newest First";

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

@@ -1,4 +1,5 @@
 import { LISTING_TYPE_CAPABILITIES } from "../capabilities";
+import { alwaysAvailable, STOCK_ONLY_UNAVAILABLE_CLAUSES, } from "../availability";
 import { ROUTES } from "../../../../next/routing/route-map";
 import { TABLE_KEYS } from "../../../../constants/table-keys";
 import { STANDARD_SORT_OPTIONS, STANDARD_PUBLIC_SORT_OPTIONS, } from "../../../../features/products/constants/sieve";
@@ -18,6 +19,10 @@ export const config = {
     chipLabel: "Classifieds",
     browseRoute: String(ROUTES.PUBLIC.CLASSIFIED),
     hideDefault: "sold",
+    // Runs out rather than ending — no time dimension, so the shared
+    // stock-only rules are the whole story for this type.
+    isAvailable: alwaysAvailable,
+    unavailableClauses: STOCK_ONLY_UNAVAILABLE_CLAUSES,
     sortOptions: STANDARD_SORT_OPTIONS,
     publicSortOptions: STANDARD_PUBLIC_SORT_OPTIONS,
     extraFacetKeys: [

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

@@ -1,3 +1,4 @@
+import { type AvailabilityRow } from "../availability";
 export declare const LISTING_TYPE: "digital-code";
 export declare const capability: import("../capabilities").ListingTypeCapability;
 export declare const config: {
@@ -17,6 +18,16 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     hideDefault: "sold";
+    isAvailable: (row: AvailabilityRow) => boolean;
+    unavailableClauses: ({
+        field: "digitalCode.codesAvailable";
+        op: "eq";
+        value: number;
+    } | {
+        field: "availableQuantity";
+        op: "eq";
+        value: number;
+    })[];
     sortOptions: readonly [{
         readonly value: string;
         readonly label: "Newest First";

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

@@ -1,9 +1,23 @@
 import { LISTING_TYPE_CAPABILITIES } from "../capabilities";
+import { num } from "../availability";
 import { ROUTES } from "../../../../next/routing/route-map";
 import { TABLE_KEYS } from "../../../../constants/table-keys";
+import { PRODUCT_FIELDS } from "../../../../constants/field-names";
 import { STANDARD_SORT_OPTIONS, STANDARD_PUBLIC_SORT_OPTIONS, } from "../../../../features/products/constants/sieve";
 export const LISTING_TYPE = "digital-code";
 export const capability = LISTING_TYPE_CAPABILITIES["digital-code"];
+/**
+ * Read the pool counter from either row shape. A Firestore document nests it
+ * under `digitalCode`; a row that has been through a Sieve projection or the
+ * listingProcessor Function can carry the flattened dotted key instead.
+ */
+function readCodesAvailable(row) {
+    const nested = row.digitalCode;
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+        return nested.codesAvailable;
+    }
+    return row[PRODUCT_FIELDS.DIGITAL_CODES_AVAILABLE];
+}
 export const config = {
     listingType: LISTING_TYPE,
     slugPrefix: "digitalcode-",
@@ -17,9 +31,15 @@ export const config = {
     pluralLabel: "Digital Codes",
     chipLabel: "Digital Codes",
     browseRoute: String(ROUTES.PUBLIC.DIGITAL_CODES),
-    // "Sold out" for a code pool means codesAvailable hit 0, which the
-    // stockQuantity>0 predicate mirrors on this collection.
+    // "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.
     hideDefault: "sold",
+    isAvailable: (row) => num(readCodesAvailable(row)) !== 0,
+    unavailableClauses: [
+        { field: PRODUCT_FIELDS.DIGITAL_CODES_AVAILABLE, op: "eq", value: 0 },
+        { field: PRODUCT_FIELDS.AVAILABLE_QUANTITY, op: "eq", value: 0 },
+    ],
     sortOptions: STANDARD_SORT_OPTIONS,
     publicSortOptions: STANDARD_PUBLIC_SORT_OPTIONS,
     extraFacetKeys: [TABLE_KEYS.DELIVERY_METHOD],

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

@@ -1,3 +1,4 @@
+import { alwaysAvailable } from "../availability";
 export declare const LISTING_TYPE: "live";
 export declare const capability: import("../capabilities").ListingTypeCapability;
 export declare const config: {
@@ -17,6 +18,8 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     hideDefault: "sold";
+    isAvailable: typeof alwaysAvailable;
+    unavailableClauses: readonly import("../availability").UnavailableClause[];
     sortOptions: readonly [{
         readonly value: string;
         readonly label: "Newest First";