@mohasinac/appkit 4.53.0 → 4.53.2

package/dist/_internal/server/features/digital-code/pool.js

@@ -26,10 +26,25 @@ import { PRODUCT_COLLECTION, PRODUCT_CODES_SUBCOLLECTION, } from "../../../../fe
 /**
  * Where a delivered asset's bytes live.
  *
- * Deliberately OUTSIDE every prefix the public media proxy knows how to resolve,
- * and no `mediaAssets` row is ever created for it — a `mediaAssets` row is what
- * mints a `/media/{shortId}` slug, and that slug is served without
- * authentication. No row, no slug, no public URL.
+ * No `mediaAssets` row is ever created for one — a row is what mints a
+ * `/media/{shortId}` slug, and that slug is served without authentication. No
+ * row, no slug, no public URL. That half was, and remains, true.
+ *
+ * 🛑 CORRECTED 2026-10-19. This block used to open with "deliberately OUTSIDE
+ * every prefix the public media proxy knows how to resolve", and that was
+ * FALSE from the day the proxy's raw-path fallback shipped: `/media/[...slug]`
+ * treats any multi-segment slug it cannot resolve through `mediaAssets` as a
+ * literal storage path, so `/media/private/digital-content/...` resolved and
+ * served. It did watermark, so no pristine original leaked — but a paid asset
+ * was reachable by anyone who guessed the object name, and the only thing
+ * standing in the way was `randomUUID()`.
+ *
+ * The proxy now refuses a raw path under `private/` outright
+ * (`PRIVATE_PREFIX` in `src/app/api/media/[...slug]/route.ts`), so the
+ * statement is true again — but it is true because of a check, not because of
+ * the prefix, and that distinction is the whole reason this comment was wrong
+ * for so long. An unenforced invariant written as a fact is worse than no
+ * comment: it is the reason nobody looked.
  */
 export const DIGITAL_CONTENT_PREFIX = "private/digital-content";
 /**

package/dist/_internal/server/features/live/metadata.js

@@ -29,7 +29,7 @@ export function buildLiveItemMetadata(product, opts) {
             description,
             url: canonical,
             type: "website",
-            images: image ? [{ url: image }] : undefined,
+            images: image ? [{ url: typeof image === "string" ? image : image.url }] : undefined,
         },
         twitter: {
             card: image ? "summary_large_image" : "summary",

package/dist/_internal/server/features/live/og.d.ts

@@ -10,7 +10,9 @@ interface LiveItemDocLike {
     price?: number | null;
     currency?: string | null;
     mainImage?: string | null;
-    images?: (string | null | undefined)[] | null;
+    images?: ({
+        url: string;
+    } | string | null | undefined)[] | null;
     liveItem?: {
         species?: string;
     } | null;

package/dist/_internal/server/features/live/og.js

@@ -4,7 +4,9 @@ export function renderLiveItemOg(doc, opts) {
     return renderLiveItemOgImage({
         title: doc?.title ?? "Live Listing",
         species: doc?.liveItem?.species ?? null,
-        imageUrl: resolveOgImageUrl(doc?.mainImage || doc?.images?.[0] || null, opts.baseUrl),
+        imageUrl: resolveOgImageUrl(doc?.mainImage ||
+            (typeof doc?.images?.[0] === "string" ? doc.images[0] : doc?.images?.[0]?.url) ||
+            null, opts.baseUrl),
     }, opts.siteName);
 }
 export function renderLiveItemOgImage(data, siteName) {

package/dist/_internal/server/features/messages/actions.js

@@ -160,7 +160,7 @@ export async function sendMessage(input) {
             productRef = {
                 productId: product.id,
                 title: product.title,
-                image: product.images?.[0],
+                image: product.images?.[0]?.url,
                 price: product.price,
                 // Without this the card cannot pick the right detail route — see the
                 // field's own comment on `MessageProductRef`.

package/dist/_internal/server/features/parts/og.js

@@ -58,7 +58,7 @@ export function renderPartOg(part, usedByCount, opts) {
 /** One classification's card. */
 export function renderPartClassificationOg(slot, count, opts) {
     const label = PART_SLOT_LABEL[slot] ?? slot;
-    return shell("Parts database", label, 
+    return shell("Beyblade parts gallery", label, 
     // `count` comes from the same bounded read the page renders, so the number
     // on the card is the number on the page. A separate count query would be a
     // second source that could disagree.

package/dist/_internal/server/features/pre-orders/og.d.ts

@@ -8,7 +8,9 @@ interface PreOrderDocLike {
     title?: string | null;
     preOrderReleaseDate?: Date | string | null;
     mainImage?: string | null;
-    images?: (string | null | undefined)[] | null;
+    images?: ({
+        url: string;
+    } | string | null | undefined)[] | null;
 }
 /** High-level OG renderer — accepts the raw pre-order document from `getPreOrderForDetail`. */
 export declare function renderPreOrderOg(doc: PreOrderDocLike | null | undefined, opts: {

package/dist/_internal/server/features/pre-orders/og.js

@@ -12,7 +12,9 @@ export function renderPreOrderOg(doc, opts) {
     return renderPreOrderOgImage({
         title: doc?.title ?? "Pre-Order",
         releaseDateLabel,
-        imageUrl: resolveOgImageUrl(doc?.mainImage || doc?.images?.[0] || null, opts.baseUrl),
+        imageUrl: resolveOgImageUrl(doc?.mainImage ||
+            (typeof doc?.images?.[0] === "string" ? doc.images[0] : doc?.images?.[0]?.url) ||
+            null, opts.baseUrl),
     }, opts.siteName);
 }
 export function renderPreOrderOgImage(data, siteName) {

package/dist/_internal/server/features/price-index/market.d.ts

@@ -0,0 +1,57 @@
+import { PRICE_GUIDANCE_TAX_BASIS } from "../../../shared/features/categories/price-guidance";
+export interface PriceIndexMarketRow {
+    categoryId: string;
+    /**
+     * The typical ASK, not a transaction.
+     *
+     * 🛑 `median` is the only required figure, and the three optional ones are
+     * optional because the crawl genuinely did not measure them everywhere — Hot
+     * Wheels has a median over n=7,418 and a RANGE, never quartiles, and the
+     * Beyblade-top table carries no per-leaf `n` at all. An absent field must
+     * render as absent; filling one in to make the shape look complete is the
+     * single thing `price-bands.md` warns about most.
+     */
+    median: number;
+    p25?: number;
+    p75?: number;
+    sampleSize?: number;
+    asOf?: string;
+    /**
+     * The share of competitor listings at this level that are SOLD OUT (0.85,
+     * measured across the five largest catalogues).
+     *
+     * Carried because it is what stops the band being read as a clearing price:
+     * most asks at this level did not convert. The renderer must say so.
+     */
+    soldOutShare?: number;
+    /** Which crawl, and any caveat — pooling, a disagreeing source, a small n. */
+    source?: string;
+    /**
+     * `true` when the band came from an ANCESTOR rather than this leaf.
+     *
+     * 🛑 Load-bearing, not decoration. `MARKET_BANDS` is keyed on era and part
+     * leaves, never on the ~216 named-model leaves, so a model lookup resolves
+     * its generation's band — "typical for Burst DB" is a true statement and
+     * "typical for Rage Longinus" is not. The renderer names the source leaf so
+     * the reader can tell which they are being told.
+     */
+    inherited: boolean;
+    /** The ancestor the band actually came from, when `inherited`. */
+    viaCategoryId?: string;
+    viaName?: string;
+    /** The basis every figure above is on. Always inclusive; stated, not assumed. */
+    taxBasis: typeof PRICE_GUIDANCE_TAX_BASIS;
+}
+/**
+ * Market bands for the leaves the client already resolved.
+ *
+ * Bounded by `PRICE_INDEX_SEARCH_LIMIT` — the same cap the public half uses, so
+ * a crafted request cannot demand an unbounded read, and the two halves of one
+ * lookup can never disagree about how many rows a lookup covers.
+ *
+ * A leaf with no band at any level is ABSENT from the result rather than
+ * present with a null band. "We have no market evidence for this" and "this id
+ * does not exist" are different answers and the caller renders them
+ * differently; collapsing them is how a missing band becomes a confident ₹0.
+ */
+export declare function getPriceIndexMarketForIds(rawIds: readonly string[]): Promise<PriceIndexMarketRow[]>;

package/dist/_internal/server/features/price-index/market.js

@@ -0,0 +1,120 @@
+/*
+ * WHY: The realised-price tool rendered "No completed sales recorded here yet"
+ *      for every single lookup, because the only data it read was OUR completed
+ *      sales and we have none for most leaves. Meanwhile the competitor crawl
+ *      measured ~60 real bands (`MARKET_BANDS` in
+ *      `seed/_helpers/category-content.ts`, evidence in
+ *      `docs/research/competitor-crawl-2026-10/price-bands.md`) which were
+ *      seeded onto the taxonomy and then read by exactly one surface — the
+ *      seller form's hint. The tool had a starting point the whole time and
+ *      never looked at it.
+ * WHAT: The MARKET half of the tool, resolved by the shared nearest-first
+ *       ancestor walk. Signed-in only — see the gate note below.
+ *
+ * EXPORTS:
+ *   PriceIndexMarketRow           — one leaf's market band, API shape
+ *   getPriceIndexMarketForIds     — N category ids -> their market bands
+ *
+ * ── 🛑 WHY THIS IS A SEPARATE, AUTHENTICATED ENDPOINT ───────────────────────
+ *
+ * The sold half (`searchPriceIndex`, `getPriceIndexBandsForIds`) is PUBLIC and
+ * edge-cached, deliberately: a day-stale aggregate of our own completed sales
+ * is the strongest content we can publish and is not what the guest price gate
+ * protects. The market half is the opposite call, and the reasoning is already
+ * written down at `categories/api/[id]/price-guidance/route.ts`: publishing a
+ * competitor-derived band on an unauthenticated, publicly-cacheable response
+ * "would be exactly the 'a neighbouring surface publishes the range' leak that
+ * gate exists to close".
+ *
+ * So the two halves cannot share a response. Merging `market` into
+ * `getPriceIndexBandsForIds` would either poison that public cache with
+ * viewer-dependent content — one signed-in lookup populating the entry every
+ * guest then reads, the exact failure `cachedPublicRead`'s rules exist to
+ * prevent — or force the public half to go private and lose its cache. A
+ * sibling endpoint keeps both postures correct, and it is the same split the
+ * codebase already uses for `description-template` (public) against
+ * `price-guidance` (gated).
+ *
+ * ── 🛑 WHAT IS NOT DONE HERE: the seller tax-basis conversion ───────────────
+ *
+ * The seller route restates the band on the caller's own `pricesIncludeGst`
+ * basis. This one does not, for two reasons. The figures are tax-inclusive
+ * (`PRICE_GUIDANCE_TAX_BASIS`) and so is every price a buyer sees anywhere on
+ * the site, so for the tool's audience no conversion is the correct answer
+ * rather than a missing feature. And the conversion needs a store read per
+ * lookup, which on a tool that resolves up to eight leaves at a time would be
+ * a per-request cost paid to restate a number most callers want as stored. The
+ * renderer labels the basis instead.
+ *
+ * @tag domain:price-index
+ * @tag layer:server
+ * @tag pattern:projection
+ * @tag access:server-only
+ * @tag consumers:api/tools/price-index/market
+ * @tag sideEffects:none
+ */
+import { resolveInheritedGuidanceMany } from "../categories/price-guidance-resolve.js";
+import { PRICE_GUIDANCE_TAX_BASIS } from "../../../shared/features/categories/price-guidance.js";
+import { PRICE_INDEX_SEARCH_LIMIT } from "./search.js";
+/**
+ * Market bands for the leaves the client already resolved.
+ *
+ * Bounded by `PRICE_INDEX_SEARCH_LIMIT` — the same cap the public half uses, so
+ * a crafted request cannot demand an unbounded read, and the two halves of one
+ * lookup can never disagree about how many rows a lookup covers.
+ *
+ * A leaf with no band at any level is ABSENT from the result rather than
+ * present with a null band. "We have no market evidence for this" and "this id
+ * does not exist" are different answers and the caller renders them
+ * differently; collapsing them is how a missing band becomes a confident ₹0.
+ */
+export async function getPriceIndexMarketForIds(rawIds) {
+    const ids = [...new Set(rawIds.filter((id) => typeof id === "string" && id.length > 0))].slice(0, PRICE_INDEX_SEARCH_LIMIT);
+    if (ids.length === 0)
+        return [];
+    const guidanceById = await resolveInheritedGuidanceMany(ids);
+    const rows = [];
+    for (const id of ids) {
+        const resolved = guidanceById.get(id);
+        const market = resolved?.guidance.market;
+        // No band anywhere up the chain. Omitted, never zeroed.
+        if (!market || !resolved)
+            continue;
+        rows.push({
+            categoryId: id,
+            median: market.median,
+            ...(market.p25 === undefined ? {} : { p25: market.p25 }),
+            ...(market.p75 === undefined ? {} : { p75: market.p75 }),
+            ...(market.sampleSize === undefined ? {} : { sampleSize: market.sampleSize }),
+            ...(toIso(market.asOf) ? { asOf: toIso(market.asOf) } : {}),
+            ...(market.soldOutShare === undefined ? {} : { soldOutShare: market.soldOutShare }),
+            ...(market.source ? { source: market.source } : {}),
+            inherited: resolved.inherited,
+            /*
+             * Only when inherited. Naming the leaf as its own source would be noise
+             * on a card that is already headed by that leaf's name.
+             */
+            ...(resolved.inherited
+                ? {
+                    viaCategoryId: resolved.fromCategoryId,
+                    ...(resolved.fromName ? { viaName: resolved.fromName } : {}),
+                }
+                : {}),
+            taxBasis: PRICE_GUIDANCE_TAX_BASIS,
+        });
+    }
+    return rows;
+}
+/** Firestore `Timestamp` | `Date` | ISO string -> ISO string. */
+function toIso(v) {
+    if (!v)
+        return undefined;
+    if (v instanceof Date)
+        return v.toISOString();
+    if (typeof v === "string")
+        return v;
+    const t = v;
+    if (typeof t.toDate === "function")
+        return t.toDate().toISOString();
+    return undefined;
+}

package/dist/_internal/server/features/price-index/search.d.ts

@@ -117,3 +117,21 @@ export interface PriceIndexSearchResponse {
  * Cost: one `searchTxt` push-down query plus ONE multi-get. Both bounded.
  */
 export declare function searchPriceIndex(rawQuery: string): Promise<PriceIndexSearchResponse>;
+/**
+ * Tier 1 adoption — the client already resolved candidate leaves LOCALLY via
+ * the public search artifact (`useSiteSearch({ types: ["model", "category"] })`),
+ * at zero Firestore reads. This is the ONLY query this path still needs: one
+ * multi-get, bounded by however many ids the client resolved (capped the
+ * same as the search path, so a crafted request cannot demand an unbounded
+ * `getAll`).
+ *
+ * 🛑 Deliberately NOT filtering brand/bundle categoryType here — the CALLER
+ * already did that at index-build time (`PUBLIC_INDEX_SOURCES`'s category
+ * source only emits real listing leaves under the "model"/"category" type
+ * keys), so re-deriving the same filter from a bare id list would be a
+ * second, independently-maintained copy of a rule that already lives in one
+ * place. If that assumption is ever wrong, the cost is a band shown for a
+ * brand/bundle row — cosmetic, not a leak, since no money figure is ever
+ * attached to a document that does not already have sales recorded.
+ */
+export declare function getPriceIndexBandsForIds(rawIds: readonly string[]): Promise<PriceIndexSearchResult[]>;

package/dist/_internal/server/features/price-index/search.js

@@ -154,8 +154,22 @@ export async function searchPriceIndex(rawQuery) {
         return !t || t === "category" || t === "sublisting";
     });
     const page = listingRows.slice(0, PRICE_INDEX_SEARCH_LIMIT);
-    const bandsByLeaf = await priceIndexRepository.getManyForLeaves(page.map((c) => c.id));
-    const results = page.map((c) => {
+    const results = await buildBandsForLeaves(page);
+    return {
+        ...base,
+        results,
+        truncated: listingRows.length > PRICE_INDEX_SEARCH_LIMIT,
+    };
+}
+/**
+ * The ONE multi-get, shared by the search path above and the ids-only path
+ * below — the actual band-shaping logic (sort by sample size, omit an empty
+ * `bands` array, the "no sales recorded" vs "zero sales" distinction) must
+ * answer identically regardless of how the category list was resolved.
+ */
+async function buildBandsForLeaves(leaves) {
+    const bandsByLeaf = await priceIndexRepository.getManyForLeaves(leaves.map((c) => c.id));
+    return leaves.map((c) => {
         const doc = bandsByLeaf.get(c.id);
         const bands = doc
             ? Object.entries(doc.byListingType ?? {})
@@ -180,9 +194,35 @@ export async function searchPriceIndex(rawQuery) {
             ...(doc ? { windowDays: doc.windowDays, computedAt: toIso(doc.computedAt) } : {}),
         };
     });
-    return {
-        ...base,
-        results,
-        truncated: listingRows.length > PRICE_INDEX_SEARCH_LIMIT,
-    };
+}
+/**
+ * Tier 1 adoption — the client already resolved candidate leaves LOCALLY via
+ * the public search artifact (`useSiteSearch({ types: ["model", "category"] })`),
+ * at zero Firestore reads. This is the ONLY query this path still needs: one
+ * multi-get, bounded by however many ids the client resolved (capped the
+ * same as the search path, so a crafted request cannot demand an unbounded
+ * `getAll`).
+ *
+ * 🛑 Deliberately NOT filtering brand/bundle categoryType here — the CALLER
+ * already did that at index-build time (`PUBLIC_INDEX_SOURCES`'s category
+ * source only emits real listing leaves under the "model"/"category" type
+ * keys), so re-deriving the same filter from a bare id list would be a
+ * second, independently-maintained copy of a rule that already lives in one
+ * place. If that assumption is ever wrong, the cost is a band shown for a
+ * brand/bundle row — cosmetic, not a leak, since no money figure is ever
+ * attached to a document that does not already have sales recorded.
+ */
+export async function getPriceIndexBandsForIds(rawIds) {
+    const ids = [...new Set(rawIds.filter((id) => typeof id === "string" && id.length > 0))].slice(0, PRICE_INDEX_SEARCH_LIMIT);
+    if (ids.length === 0)
+        return [];
+    const docs = await categoriesRepository.getManyByIds(ids);
+    const leaves = docs.map((c) => ({
+        id: c.id,
+        name: c.name,
+        slug: c.slug,
+        path: c.path,
+        display: c.display,
+    }));
+    return buildBandsForLeaves(leaves);
 }

package/dist/_internal/server/features/prize-draws/og.d.ts

@@ -17,7 +17,9 @@ interface PrizeDrawDocLike {
     price?: number | null;
     currency?: string | null;
     mainImage?: string | null;
-    images?: (string | null | undefined)[] | null;
+    images?: ({
+        url: string;
+    } | string | null | undefined)[] | null;
     prizeRevealStatus?: "pending" | "open" | "closed" | null;
     prizeMaxEntries?: number | null;
     prizeCurrentEntries?: number | null;

package/dist/_internal/server/features/prize-draws/og.js

@@ -19,7 +19,9 @@ export function renderPrizeDrawOg(doc, opts) {
     return renderPrizeDrawOgImage({
         title: doc?.title ?? doc?.name ?? "Prize Draw",
         pricePerEntryLabel,
-        imageUrl: resolveOgImageUrl(doc?.mainImage || doc?.images?.[0] || null, opts.baseUrl),
+        imageUrl: resolveOgImageUrl(doc?.mainImage ||
+            (typeof doc?.images?.[0] === "string" ? doc.images[0] : doc?.images?.[0]?.url) ||
+            null, opts.baseUrl),
         revealStatus: doc?.prizeRevealStatus ?? null,
         entriesLabel,
     }, opts.siteName);

package/dist/_internal/server/features/products/group-members.d.ts

@@ -42,6 +42,16 @@ export interface PublicGroupMember {
     groupTitle?: string;
     /** Drives the stepper's `max`. */
     availableQuantity: number;
+    /**
+     * Made to order — the stepper is UNCAPPED for this member.
+     *
+     * 🛑 This is an ALLOW-LIST projection: a field absent from this interface and
+     * from `toPublicGroupMember` below simply does not reach the picker, with no
+     * error anywhere. Without it the picker reads `availableQuantity: 0` on a
+     * print-on-demand member and caps the stepper at zero — the member renders,
+     * looks selectable, and cannot be chosen.
+     */
+    madeToOrder?: boolean;
     storeId: string;
     storeName?: string;
     status: string;
@@ -50,6 +60,22 @@ export interface PublicGroupMember {
      *  snapshot it for per-member GST proration at checkout. */
     gstRate?: 0 | 5 | 12 | 18 | 28;
     hsnCode?: string;
+    /**
+     * The group's OWN selection rules — present only on the PARENT row, since
+     * that is the only document that carries them.
+     *
+     * 🛑 Projected so `readGroupRules` has something real to read client-side.
+     * Without these the picker would silently see no rules on every page that
+     * derives them from this endpoint's own response (`ShowGroupSection`),
+     * which is a client-only regression of the exact kind E3 exists to close —
+     * a server-only rule reads as a broken button, and here it would be the
+     * reverse: a client that never finds out a rule exists at all.
+     */
+    groupMinMembers?: number;
+    groupMaxMembers?: number;
+    groupMaxUnitsPerMember?: number;
+    groupRequiredMemberIds?: string[];
+    groupDiscountPercent?: number;
 }
 export declare function toPublicGroupMember(doc: ProductDocument): PublicGroupMember;
 export declare function toPublicGroupMembers(docs: readonly ProductDocument[]): PublicGroupMember[];

package/dist/_internal/server/features/products/group-members.js

@@ -22,18 +22,24 @@ export function toPublicGroupMember(doc) {
         title: doc.title,
         price: doc.price,
         currency: doc.currency,
-        image: doc.images?.[0] ?? doc.mainImage,
+        image: doc.images?.[0]?.url ?? doc.mainImage,
         condition: doc.condition,
         listingType: normalizeListingType(doc),
         isGroupParent: doc.isGroupParent,
         groupTitle: doc.groupTitle,
         availableQuantity: doc.availableQuantity ?? 0,
+        madeToOrder: doc.madeToOrder,
         storeId: doc.storeId,
         storeName: doc.storeName,
         status: doc.status,
         isSold: doc.isSold,
         gstRate: doc.gstRate,
         hsnCode: doc.hsnCode,
+        groupMinMembers: doc.groupMinMembers,
+        groupMaxMembers: doc.groupMaxMembers,
+        groupMaxUnitsPerMember: doc.groupMaxUnitsPerMember,
+        groupRequiredMemberIds: doc.groupRequiredMemberIds,
+        groupDiscountPercent: doc.groupDiscountPercent,
     };
 }
 export function toPublicGroupMembers(docs) {

package/dist/_internal/server/features/products/list-public.d.ts

@@ -1,5 +1,6 @@
 import { type ViewerLike } from "../tester/visibility";
 import type { JsonValue } from "../../../../schemas/types";
+import type { UnavailableClause } from "../../../shared/listing-types/availability";
 import { type AvailabilityFilter } from "../../../../constants/field-names";
 /** Vercel Hobby Fluid Compute ceiling (CLAUDE.md Rule #6) — never fetch more at once. */
 export declare const PUBLIC_PRODUCT_MAX_PAGE_SIZE = 50;
@@ -250,6 +251,17 @@ export declare function parsePublicProductParams(params: URLSearchParams | Recor
      */
     availability?: AvailabilityFilter;
 }): PublicProductListInput;
+/** Render one `UnavailableClause` as a Sieve clause against a fixed `now`. */
+/**
+ * One unavailable clause → a Sieve fragment, with `"NOW"` bound to this
+ * query's timestamp.
+ *
+ * Exported so `listing-tab-counts` builds its clause queries with THIS
+ * function rather than a second copy. A rule reachable by copy-paste is one
+ * that gets copied wrong (Root Cause #75), and the two would only diverge the
+ * day someone adds a third `op`.
+ */
+export declare function clauseToSieve(clause: UnavailableClause, now: Date): string;
 export declare function listPublicProducts(input: PublicProductListInput, opts?: PublicProductListOptions): Promise<PublicProductListResult | null>;
 /**
  * One store tab's worth of listings.

package/dist/_internal/server/features/products/list-public.js

@@ -440,7 +440,16 @@ async function defaultExecutor(query) {
     };
 }
 /** Render one `UnavailableClause` as a Sieve clause against a fixed `now`. */
-function clauseToSieve(clause, now) {
+/**
+ * One unavailable clause → a Sieve fragment, with `"NOW"` bound to this
+ * query's timestamp.
+ *
+ * Exported so `listing-tab-counts` builds its clause queries with THIS
+ * function rather than a second copy. A rule reachable by copy-paste is one
+ * that gets copied wrong (Root Cause #75), and the two would only diverge the
+ * day someone adds a third `op`.
+ */
+export function clauseToSieve(clause, now) {
     const value = clause.value === "NOW" ? now.toISOString() : clause.value;
     return clause.op === "lt"
         ? sieveFilter(clause.field, SIEVE_OP.LT, value)

package/dist/_internal/server/features/products/listing-tab-counts.d.ts

@@ -31,6 +31,28 @@ export interface ListingTabScope {
  * `undefined` as "keep the tab visible" (Root Cause #59).
  */
 export type ListingTabCounts = Record<string, number | undefined>;
+/**
+ * The two numbers a tab bar needs, and they are NOT the same number.
+ *
+ * 🛑 A badge showing `total` while the panel below it defaults to the
+ * AVAILABLE scope is a tab that advertises rows it will not render. That was
+ * live: a category holding one `prizeRevealStatus: "closed"` draw showed
+ * "Prize Draws 1" above "No prize draws found." — accurate counting of the
+ * wrong question, Root Cause #72's family.
+ *
+ *   `available` — what the default scope will render. The BADGE.
+ *   `total`     — every published row in scope, across all availability
+ *                 scopes. The hide-at-zero decision, and the "N ended —
+ *                 view All" hint under an empty panel.
+ *
+ * 🛑 Hiding must stay keyed on `total`. A tab whose rows have all ended still
+ * has a browsable archive behind the Ended/All scopes; hiding it at
+ * `available === 0` would make that archive unreachable.
+ */
+export interface ListingTabCountResult {
+    available: ListingTabCounts;
+    total: ListingTabCounts;
+}
 /**
  * Count every tab in `tabs` within `scope`, in one parallel batch.
  *
@@ -41,4 +63,6 @@ export type ListingTabCounts = Record<string, number | undefined>;
  * `stores` is not counted here: only the category page has that tab and it
  * already resolves its store list eagerly to render the tab body.
  */
-export declare function listingTabCounts(tabs: readonly ListingTab[], scope: ListingTabScope): Promise<ListingTabCounts>;
+export declare function listingTabCounts(tabs: readonly ListingTab[], scope: ListingTabScope, opts?: {
+    now?: Date;
+}): Promise<ListingTabCountResult>;