@mohasinac/appkit 4.52.5 → 4.53.1

package/dist/features/sticker-trace/schemas/firestore.d.ts

@@ -0,0 +1,267 @@
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
+import type { PrecisionTier, Rect, ScanType, TraceParams, TraceStage } from "../../../_internal/shared/features/sticker-trace/types";
+export declare const STICKER_SHEETS_COLLECTION = "stickerSheets";
+export declare const STICKER_TRACE_RUNS_COLLECTION = "stickerTraceRuns";
+export declare const STICKER_TRACE_TASKS_COLLECTION = "stickerTraceTasks";
+export declare const TraceRunStatusValues: {
+    readonly QUEUED: "queued";
+    readonly RUNNING: "running";
+    readonly SUCCEEDED: "succeeded";
+    readonly FAILED: "failed";
+    readonly CANCELLED: "cancelled";
+};
+export type TraceRunStatus = (typeof TraceRunStatusValues)[keyof typeof TraceRunStatusValues];
+/**
+ * Where the scan's resolution came from.
+ *
+ * 🛑 `embedded` is NOT a measurement. Five of the nine reference scans declare
+ * 72 or 96 dpi, which is a number the encoder wrote rather than anything about
+ * the scanner — so the value is always shown and always confirmable, and a
+ * sheet with no trustworthy dpi carries `bboxMm: null` rather than a plausible
+ * figure. A fabricated millimetre on a cut file is a physical production error,
+ * which is a different class of wrong from a missing one.
+ */
+export declare const DpiSourceValues: {
+    readonly EMBEDDED: "embedded";
+    readonly MANUAL: "manual";
+    readonly CALIBRATED: "calibrated";
+};
+export type DpiSource = (typeof DpiSourceValues)[keyof typeof DpiSourceValues];
+/** One object in Storage. `assetPath` is private and never leaves the server. */
+export interface StoredAsset {
+    assetPath: string;
+    contentType: string;
+    bytes: number;
+    /**
+     * Lets a re-upload of identical bytes be recognised rather than re-traced.
+     *
+     * 🛑 OPTIONAL, and CLIENT-SUPPLIED, and therefore a DEDUPE HINT rather than
+     * an integrity check — all three of those are the same fact stated three
+     * ways, and conflating them is how a hash field starts being trusted.
+     *
+     * The server cannot compute it. Hashing the object means downloading all of
+     * it into a Vercel function, and `@ShayBlader Scan 18` is 79 MB — that is
+     * precisely the egress mistake the whole storage module is built to avoid
+     * (Root Cause #104, which paused this project at 52.52 GB against a 10 GB
+     * allowance). GCS does return a server-computed digest in object metadata,
+     * but it is md5/crc32c; putting one of those in a field named `sha256` would
+     * be a worse lie than leaving the field empty.
+     *
+     * The browser already holds the bytes — it decoded them for live tuning — so
+     * it can hash them with SubtleCrypto for free. It was REQUIRED until
+     * 2026-10-19, with no producer and no reader anywhere, which is the shape
+     * that gets a field filled with a fabricated value by the first caller that
+     * has to satisfy the compiler.
+     */
+    sha256?: string;
+}
+/**
+ * What a RUN produces — about 2.5 MB, every time, for every attempt.
+ *
+ * 🛑 `thumbAtlasPath` is ONE sprite sheet, not N thumbnails, and that is a
+ * storage decision rather than a UI one: object COUNT is metered separately
+ * from bytes, so 60 thumbnails per run would spend Class A writes sixty times
+ * faster for the same pixels. The part bounding boxes already live in
+ * `geometry.json`, so one atlas plus those boxes is sufficient to render the
+ * list — and it loads in one request instead of sixty.
+ */
+export interface RunArtifacts {
+    previewPath?: string;
+    overlayPath?: string;
+    geometryPath?: string;
+    cutSvgPath?: string;
+    thumbAtlasPath?: string;
+}
+/**
+ * What PROMOTING a run produces — full-resolution parts and the print exports.
+ *
+ * 🛑 Deliberately separate from `RunArtifacts`, because this is the single
+ * decision that keeps the feature inside the Storage allowance. Rendering
+ * full-res parts on every run costs ~600 MB per sheet across a tuning session;
+ * rendering them only for the run actually chosen costs ~95 MB. That is the
+ * difference between roughly 8 sheets and roughly 52 inside 5 GB, which is why
+ * it is a schema boundary and not a flag.
+ */
+export interface PromotedArtifacts {
+    at: Date;
+    by: string;
+    partAssetPaths: string[];
+    cricutSvgPath?: string;
+    printThenCutSvgPath?: string;
+    pdfMosaicPath?: string;
+}
+/** What the SHEET carries once a run has been promoted onto it. */
+export interface SheetArtifacts extends RunArtifacts {
+    cricutSvgPath?: string;
+    printThenCutSvgPath?: string;
+    pdfMosaicPath?: string;
+}
+export interface SheetPart {
+    /** 1-based, stable within the run that produced it. */
+    ordinal: number;
+    /** Auto-assigned as the ordinal, renameable by the admin. */
+    name: string;
+    /** Which physical sheet, when one scan holds several. */
+    groupIndex: number;
+    bboxPx: Rect;
+    /** Null whenever dpi is untrustworthy — never a guess. */
+    bboxMm: Rect | null;
+    areaMm2: number | null;
+    /** Full-resolution PNG. Absent until the producing run is promoted. */
+    assetPath?: string;
+    /**
+     * "#7 is a copy of #3". Proposed by bbox + perceptual hash, CONFIRMED by a
+     * human — a duplicate marked automatically is one the admin never gets asked
+     * about, and two stickers that merely look alike at thumbnail size are common
+     * on these sheets.
+     */
+    duplicateOf?: number;
+    /**
+     * The `/media/{shortId}` slug of this part's PUBLIC, WATERMARKED copy.
+     *
+     * 🛑 ZERO BYTES ARE DUPLICATED. The `mediaAssets` row points at the SAME
+     * `assetPath` above — the clean original under `private/sticker-sheets/` —
+     * and is written with `watermarkedAt` deliberately ABSENT, so
+     * `/api/media/[...slug]` composites the mark on read. Clean original for the
+     * cut file, watermarked copy for the marketplace, one object.
+     *
+     * Object COUNT is metered separately from bytes (that is the whole reason the
+     * thumb atlas exists), so a second uploaded copy per part would spend Class A
+     * writes 60× faster per sheet for pixels we already have.
+     *
+     * Stored back here so re-promoting a sheet REUSES the row rather than minting
+     * a second slug for the same object and orphaning the first.
+     *
+     * Absent until the sheet has been promoted to listings.
+     */
+    mediaShortId?: string;
+}
+/**
+ * One progress transition, mirrored from RTDB so history survives the prune.
+ *
+ * 🛑 Capped at RUN_EVENTS_MAX with `eventsTruncated` recording the overflow —
+ * the same discipline as `statusHistory`. An unbounded append on a `max`-tier
+ * run with 60 shards approaches the 1 MiB document limit, and a truncation
+ * nobody counted reads as "nothing else happened".
+ */
+export interface TraceRunEvent {
+    at: Date;
+    stage: TraceStage | "queued" | "done";
+    pct: number;
+    message?: string;
+    level?: "info" | "warn" | "error";
+}
+export declare const RUN_EVENTS_MAX = 100;
+/**
+ * Why a run failed, in terms a retry panel can act on.
+ *
+ * `message` is user-safe — resolved through `toUserMessage`, never raw server
+ * text. A Node `MODULE_NOT_FOUND` with a require stack rendered inside a
+ * progress panel is Root Cause #86, and it reached a buyer's bid modal once
+ * already.
+ */
+export interface TraceRunError {
+    stage: TraceStage | "queued";
+    code: string;
+    message: string;
+    /** Present when a SHARD failed, so the panel can name the part. */
+    partOrdinal?: number;
+}
+export interface StickerSheetDocument extends BaseDocument {
+    /**
+     * 🛑 MANDATORY. Nothing processes without one.
+     *
+     * The whole point of keeping every attempt is being able to tell them apart
+     * later, and "Untitled (3)" defeats that at the moment it matters most.
+     */
+    title: string;
+    scanType: ScanType;
+    dpi?: number;
+    dpiSource?: DpiSource;
+    widthPx: number;
+    heightPx: number;
+    sourceScan: StoredAsset;
+    /** The run whose result this sheet currently shows. */
+    activeRunId?: string;
+    traceStatus: TraceRunStatus;
+    partCount: number;
+    groupCount: number;
+    artifacts: SheetArtifacts;
+    parts: SheetPart[];
+}
+export interface StickerTraceRunDocument extends BaseDocument {
+    sheetId: string;
+    /** 🛑 MANDATORY — "Run 3 — precise, tighter hysteresis". See the sheet's title. */
+    name: string;
+    tier: PrecisionTier;
+    /**
+     * The parameters this run ACTUALLY used, recorded rather than recomputed.
+     *
+     * Grouped by stage in `TraceParams` itself, which is what makes resume safe:
+     * `resumeStage = max(requested, earliestChangedParamStage)`. Without that
+     * clamp a run resumed from `parts` with a different ridge threshold produces
+     * artifacts generated under different parameters than the run records, and
+     * nothing anywhere contradicts it (Root Cause #42's shape).
+     */
+    params: TraceParams;
+    requestedBy: string;
+    startedAt?: Date;
+    finishedAt?: Date;
+    durationMs?: number;
+    status: TraceRunStatus;
+    /** The stage it is in — or the stage it DIED in. */
+    stage?: TraceStage | "queued" | "done";
+    events: TraceRunEvent[];
+    eventsTruncated?: number;
+    partCount: number;
+    groupCount: number;
+    shardCount?: number;
+    error?: TraceRunError;
+    artifacts: RunArtifacts;
+    promoted?: PromotedArtifacts | null;
+    /** Set when retention strips the light artifacts; the row outlives its images. */
+    artifactsPruned?: boolean;
+}
+/**
+ * A unit of fan-out work. Doc-id-keyed, and that is what makes redelivery safe.
+ *
+ * 🛑 Cloud Functions guarantee AT-LEAST-ONCE delivery. The finalize task is
+ * written with `create()` at `{runId}__finalize`, so a redelivered shard that
+ * increments the counter again fails that create harmlessly instead of
+ * spawning a second finalizer that double-renders every part.
+ *
+ * 🛑 Its trigger is `documentCreated`, never `documentWritten`. A write trigger
+ * on a collection its own shards write back into is Root Cause #92 — one
+ * million invocations a day against a two-million-a-month free quota, with a
+ * billing page as the only symptom.
+ */
+export interface StickerTraceTaskDocument extends BaseDocument {
+    runId: string;
+    sheetId: string;
+    kind: "part" | "finalize";
+    /** `trace` renders review thumbnails; `full` renders promoted parts + exports. */
+    mode: "thumb" | "full";
+    shardIndex?: number;
+    /** Ordinals this shard owns. Empty on a finalize task. */
+    partOrdinals: number[];
+}
+export declare const STICKER_SHEET_FIELDS: {
+    readonly TITLE: "title";
+    readonly SCAN_TYPE: "scanType";
+    readonly TRACE_STATUS: "traceStatus";
+    readonly ACTIVE_RUN_ID: "activeRunId";
+    readonly PART_COUNT: "partCount";
+    readonly CREATED_AT: "createdAt";
+    readonly UPDATED_AT: "updatedAt";
+};
+export declare const STICKER_TRACE_RUN_FIELDS: {
+    readonly SHEET_ID: "sheetId";
+    readonly NAME: "name";
+    readonly TIER: "tier";
+    readonly STATUS: "status";
+    readonly STAGE: "stage";
+    readonly REQUESTED_BY: "requestedBy";
+    readonly STARTED_AT: "startedAt";
+    readonly FINISHED_AT: "finishedAt";
+    readonly CREATED_AT: "createdAt";
+};

package/dist/features/sticker-trace/schemas/firestore.js

@@ -0,0 +1,79 @@
+/*
+ * WHY: A scanned sticker sheet becomes cut-ready geometry through a pipeline
+ *      that can fail in nine different stages, is retried with different
+ *      parameters until it is right, and must still be able to answer "what
+ *      did run 2 do differently last Tuesday" weeks later. One mutable
+ *      document cannot hold that; an attempt is a record, not an overwrite.
+ * WHAT: The two collections, and the task record that fans the work out.
+ *
+ * Collections:
+ *   stickerSheets/{stickersheet-slug}   the sheet, and its CURRENT accepted result
+ *   stickerTraceRuns/{runId}            every attempt, immutable once finished
+ *   stickerTraceTasks/{taskId}          transient shard fan-out, deleted on finalize
+ *
+ * 🛑 Every `*Path` on these documents is a RAW STORAGE PATH under
+ * `private/sticker-sheets/…` and must never reach a client. The bytes are
+ * fetched through a short-lived signed URL minted by an authenticated route —
+ * see § "Digital Content Delivery" for the precedent and why a guessable
+ * public path is the one property a private asset must not have.
+ *
+ * EXPORTS: STICKER_SHEETS_COLLECTION, STICKER_TRACE_RUNS_COLLECTION,
+ *   STICKER_TRACE_TASKS_COLLECTION, TraceRunStatusValues, TraceRunStatus,
+ *   DpiSourceValues, DpiSource, StoredAsset, SheetArtifacts, RunArtifacts,
+ *   PromotedArtifacts, SheetPart, TraceRunEvent, TraceRunError,
+ *   StickerSheetDocument, StickerTraceRunDocument, StickerTraceTaskDocument,
+ *   STICKER_SHEET_FIELDS, STICKER_TRACE_RUN_FIELDS, RUN_EVENTS_MAX
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:feature
+ * @tag pattern:firestore-schema
+ * @tag access:server
+ * @tag consumers:sticker-sheets.repository,sticker-trace-runs.repository
+ * @tag sideEffects:none
+ */
+export const STICKER_SHEETS_COLLECTION = "stickerSheets";
+export const STICKER_TRACE_RUNS_COLLECTION = "stickerTraceRuns";
+export const STICKER_TRACE_TASKS_COLLECTION = "stickerTraceTasks";
+export const TraceRunStatusValues = {
+    QUEUED: "queued",
+    RUNNING: "running",
+    SUCCEEDED: "succeeded",
+    FAILED: "failed",
+    CANCELLED: "cancelled",
+};
+/**
+ * Where the scan's resolution came from.
+ *
+ * 🛑 `embedded` is NOT a measurement. Five of the nine reference scans declare
+ * 72 or 96 dpi, which is a number the encoder wrote rather than anything about
+ * the scanner — so the value is always shown and always confirmable, and a
+ * sheet with no trustworthy dpi carries `bboxMm: null` rather than a plausible
+ * figure. A fabricated millimetre on a cut file is a physical production error,
+ * which is a different class of wrong from a missing one.
+ */
+export const DpiSourceValues = {
+    EMBEDDED: "embedded",
+    MANUAL: "manual",
+    CALIBRATED: "calibrated",
+};
+export const RUN_EVENTS_MAX = 100;
+export const STICKER_SHEET_FIELDS = {
+    TITLE: "title",
+    SCAN_TYPE: "scanType",
+    TRACE_STATUS: "traceStatus",
+    ACTIVE_RUN_ID: "activeRunId",
+    PART_COUNT: "partCount",
+    CREATED_AT: "createdAt",
+    UPDATED_AT: "updatedAt",
+};
+export const STICKER_TRACE_RUN_FIELDS = {
+    SHEET_ID: "sheetId",
+    NAME: "name",
+    TIER: "tier",
+    STATUS: "status",
+    STAGE: "stage",
+    REQUESTED_BY: "requestedBy",
+    STARTED_AT: "startedAt",
+    FINISHED_AT: "finishedAt",
+    CREATED_AT: "createdAt",
+};

package/dist/features/sticker-trace/server.d.ts

@@ -0,0 +1,8 @@
+export { runCoordinator, type CoordinatorDeps } from "../../_internal/server/features/sticker-trace/coordinator";
+export { runShard, type ShardDeps } from "../../_internal/server/features/sticker-trace/shard";
+export { runFinalizer, type FinalizerDeps } from "../../_internal/server/features/sticker-trace/finalizer";
+export { readScanBytes, readRunGeometry, writeRunArtifact, type RunGeometry, } from "../../_internal/server/features/sticker-trace/storage";
+export { rasterisePartToBox } from "../../_internal/shared/features/sticker-trace/math/rasterize-path";
+export { buildCutFileBytes, buildCutFileForRun } from "../../_internal/server/features/sticker-trace/build-cut-file";
+export { collectMosaicInputs, type MosaicInputs, type MosaicPartInput, } from "../../_internal/server/features/sticker-trace/mosaic-inputs";
+export type { PrintPageSizeId } from "../../_internal/shared/features/sticker-trace/export/page-sizes";

package/dist/features/sticker-trace/server.js

@@ -0,0 +1,51 @@
+/*
+ * WHY: A Cloud Function must not inhale the Next.js server barrel. Importing
+ *      `@mohasinac/appkit/server` from functions/ dragged in
+ *      react-server-dom-webpack and @vercel/og's wasm and FAILED the tsup
+ *      build — Root Cause #18, caught by the bundler rather than by review.
+ * WHAT: A narrow server entry for the sticker tracer, re-exporting only what a
+ *       Function binding injects, each from its DEFINING module.
+ *
+ * 🛑 This is one of the carve-outs Root Cause #18 permits: a package's public
+ * API contract. `_internal/*` is deliberately not an exported subpath, so a
+ * consumer implementing the codec seam or binding the handlers has no other way
+ * in. Modelled on the existing `./features/whatsapp-bot/server` key.
+ *
+ * 🛑 Keep it NARROW. Every symbol added here widens what a Functions bundle
+ * must resolve, and the whole reason this file exists is that the wide barrel
+ * could not be bundled at all.
+ *
+ * EXPORTS: runCoordinator, runShard, runFinalizer, readScanBytes,
+ *   readRunGeometry, writeRunArtifact, rasterisePartToBox, + their types
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:feature
+ * @tag pattern:none
+ * @tag access:server
+ * @tag consumers:functions/sticker-trace
+ * @tag sideEffects:none
+ */
+export { runCoordinator } from "../../_internal/server/features/sticker-trace/coordinator.js";
+export { runShard } from "../../_internal/server/features/sticker-trace/shard.js";
+export { runFinalizer } from "../../_internal/server/features/sticker-trace/finalizer.js";
+export { readScanBytes, readRunGeometry, writeRunArtifact, } from "../../_internal/server/features/sticker-trace/storage.js";
+export { rasterisePartToBox } from "../../_internal/shared/features/sticker-trace/math/rasterize-path.js";
+/*
+ * The cut-file exporter, for the finalizer binding.
+ *
+ * 🛑 `buildCutFileBytes` and not `buildExportSet`: the Function has a runId and
+ * a sheetId, not geometry and a pixels-per-mm figure. Exporting the pure
+ * function here would make every binding re-implement the artifact read and the
+ * working-raster-to-original dpi bridge — and that bridge is exactly where a
+ * silent factor-of-N millimetre error lives.
+ */
+export { buildCutFileBytes, buildCutFileForRun } from "../../_internal/server/features/sticker-trace/build-cut-file.js";
+/*
+ * Everything the PDF mosaic needs, assembled server-side.
+ *
+ * 🛑 `pdfkit` is Node-only and stays in functions/, but the DATA — the sheet,
+ * the promoted PNGs and the layout — comes from here. Letting the Function
+ * gather it would mean re-deriving the nest, and a preview that disagrees with
+ * the printed sheet about where a sticker sits is worse than no preview.
+ */
+export { collectMosaicInputs, } from "../../_internal/server/features/sticker-trace/mosaic-inputs.js";

package/dist/features/stores/actions/store-query-actions.d.ts

@@ -7,7 +7,7 @@
 import { type ViewerLike } from "../../../_internal/server/features/tester/visibility";
 import type { StoreDocument } from "../schemas";
 import type { ProductDocument } from "../../products/schemas";
-import type { ReviewDocument } from "../../reviews/schemas";
+import type { ReviewPlain } from "../../reviews/schemas";
 import type { FirebaseSieveResult } from "../../../providers/db-firebase";
 export interface StoreQueryListParams {
     filters?: string;
@@ -23,7 +23,7 @@ export interface StoreContentParams {
     filters?: string;
 }
 export interface StoreReviewsResult {
-    reviews: ReviewDocument[];
+    reviews: ReviewPlain[];
     averageRating: number;
     totalReviews: number;
     ratingDistribution: Record<number, number>;

package/dist/features/stores/actions/store-query-actions.js

@@ -9,7 +9,6 @@ import { sieveFilter, SIEVE_OP } from "@mohasinac/appkit";
 import { NotFoundError } from "../../../errors/index.js";
 import { filterTestDataForViewer, filterSingleTestData } from "../../../_internal/server/features/tester/visibility.js";
 const ERR_STORE_NOT_FOUND = "Store not found";
-import { maskPublicReview } from "../../../security/index.js";
 import { storeRepository } from "../repository/store.repository.js";
 import { STORE_FIELDS } from "../schemas/index.js";
 import { productRepository } from "../../products/repository/products.repository.js";
@@ -137,7 +136,13 @@ export async function getStoreReviews(storeSlug) {
     const totalReviews = reviewArrays.flat().length;
     const averageRating = totalReviews > 0 ? ratingSum / totalReviews : 0;
     return {
-        reviews: allReviews.map(maskPublicReview),
+        /*
+         * `maskedReview`, not `maskPublicReview`. The latter calls `maskName`,
+         * which refuses ciphertext by design and answers "Anonymous" — and these
+         * come from `find*` reads, which do not mask. A public store page was
+         * showing every reviewer as Anonymous.
+         */
+        reviews: allReviews.map((r) => reviewRepository.maskedReview(r)),
         averageRating,
         totalReviews,
         ratingDistribution,

package/dist/features/stores/api/[storeSlug]/auctions/route.js

@@ -46,7 +46,7 @@ export async function GET(request, context) {
         const storesRepo = db.getRepository("stores");
         const storeResult = await storesRepo.findAll({
             filters: `storeSlug==${storeSlug},status==active,isPublic==true`,
-            perPage: 1,
+            pageSize: 1,
         });
         const store = storeResult.data[0];
         if (!store) {
@@ -72,13 +72,13 @@ export async function GET(request, context) {
             sort,
             order: sort.startsWith("-") ? "desc" : "asc",
             page,
-            perPage: pageSize,
+            pageSize: pageSize,
         });
         const body = {
             items: result.data,
             total: result.total,
             page: result.page,
-            pageSize: result.perPage,
+            pageSize: result.pageSize,
             totalPages: result.totalPages,
             hasMore: result.page < result.totalPages,
         };

package/dist/features/stores/api/[storeSlug]/products/route.js

@@ -51,7 +51,7 @@ export async function GET(request, context) {
         const storesRepo = db.getRepository("stores");
         const storeResult = await storesRepo.findAll({
             filters: `storeSlug==${storeSlug},status==active,isPublic==true`,
-            perPage: 1,
+            pageSize: 1,
         });
         const store = storeResult.data[0];
         if (!store) {
@@ -77,13 +77,13 @@ export async function GET(request, context) {
             sort,
             order: sort.startsWith("-") ? "desc" : "asc",
             page,
-            perPage: pageSize,
+            pageSize: pageSize,
         });
         const body = {
             items: result.data,
             total: result.total,
             page: result.page,
-            pageSize: result.perPage,
+            pageSize: result.pageSize,
             totalPages: result.totalPages,
             hasMore: result.page < result.totalPages,
         };

package/dist/features/stores/api/[storeSlug]/reviews/route.js

@@ -52,7 +52,7 @@ export async function GET(request, context) {
         const storesRepo = db.getRepository("stores");
         const storeResult = await storesRepo.findAll({
             filters: `storeSlug==${storeSlug},status==active,isPublic==true`,
-            perPage: 1,
+            pageSize: 1,
         });
         const store = storeResult.data[0];
         if (!store) {

package/dist/features/stores/api/[storeSlug]/route.js

@@ -27,7 +27,7 @@ export async function GET(_request, context) {
         const repo = db.getRepository("stores");
         const result = await repo.findAll({
             filters: `storeSlug==${storeSlug},status==active,isPublic==true`,
-            perPage: 1,
+            pageSize: 1,
         });
         const raw = result.data[0];
         if (!raw) {

package/dist/features/stores/components/StoreDetailLayoutView.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import type { ReactNode } from "react";
-export declare const getStoreBySlug: (slug: string) => Promise<import("@mohasinac/appkit").StoreDocument | null>;
+export declare const getStoreBySlug: (slug: string) => Promise<import("..").StoreDocument | null>;
 export interface StoreDetailLayoutViewProps {
     storeSlug: string;
     /** The current active tab value: "products" | "auctions" | "reviews" | "about" */

package/dist/features/stores/components/StoreDetailLayoutView.js

@@ -1,41 +1,17 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { sieveFilter, sieveAnd, SIEVE_OP } from "@mohasinac/appkit";
 import { cache } from "react";
-import { storeRepository, siteSettingsRepository, reviewRepository, couponsRepository } from "../../../repositories/index.js";
+import { storeRepository, siteSettingsRepository } from "../../../repositories/index.js";
 import { safeRead } from "../../../errors/safe-read.js";
-import { ROUTES } from "../../../next/routing/route-map.js";
 import { Container, Main, Section, Text } from "../../../ui/index.js";
-import { STORE_PAGE_TABS } from "../../products/constants/listing-tabs.js";
-import { isListingTypeEnabled, isCategoryTypeEnabled } from "../../../_internal/shared/listing-types/feature-flags.js";
-import { pluginFor } from "../../../_internal/shared/listing-types/_registry.js";
-import { listingTabCounts, } from "../../../_internal/server/features/products/listing-tab-counts.js";
 import { getSellerTrustStatus } from "../../scams/actions/scam-actions.js";
 import { StoreHeader } from "./StoreHeader.js";
 import { StoreNavTabs } from "./StoreNavTabs.js";
 import { toStoreDetail } from "../../../_internal/server/features/stores/adapters.js";
-const STORE_LISTING_HREF = {
-    products: (slug) => String(ROUTES.PUBLIC.STORE_PRODUCTS(slug)),
-    auctions: (slug) => String(ROUTES.PUBLIC.STORE_AUCTIONS(slug)),
-    "pre-orders": (slug) => String(ROUTES.PUBLIC.STORE_PRE_ORDERS(slug)),
-    "prize-draws": (slug) => String(ROUTES.PUBLIC.STORE_PRIZE_DRAWS(slug)),
-    bundles: (slug) => String(ROUTES.PUBLIC.STORE_BUNDLES(slug)),
-    classifieds: (slug) => String(ROUTES.PUBLIC.STORE_CLASSIFIEDS(slug)),
-    "digital-codes": (slug) => String(ROUTES.PUBLIC.STORE_DIGITAL_CODES(slug)),
-    live: (slug) => String(ROUTES.PUBLIC.STORE_LIVE(slug)),
-    // Combined art + stickers, mirroring the public /art page. This used to
-    // point at STORE_PRODUCTS, which filters to `standard` — so the tab showed
-    // a real non-zero count and landed on a page with none of those items.
-    art: (slug) => String(ROUTES.PUBLIC.STORE_ART(slug)),
-};
+import { resolveStoreTabs } from "../../../_internal/server/features/stores/tabs.js";
 // The store IS this layout's subject, and `findBySlug` already returns null for
 // "no such slug" — swallowing a read failure into the same value would render
 // the "Store not found." branch below for a live store during an outage.
 export const getStoreBySlug = cache((slug) => storeRepository.findBySlug(slug));
-function tabLabel(base, count) {
-    if (!count)
-        return base;
-    return `${base} (${count.toLocaleString()})`;
-}
 export async function StoreDetailLayoutView({ storeSlug, activeTab, children, scamRegistryEnabled = false, }) {
     const store = await getStoreBySlug(storeSlug);
     if (!store) {
@@ -53,61 +29,10 @@ export async function StoreDetailLayoutView({ storeSlug, activeTab, children, sc
             ? safeRead(() => getSellerTrustStatus(storeId), { route: "/stores/[slug]", key: "store.sellerTrust", fallback: undefined })
             : Promise.resolve(undefined),
     ]);
-    // One derived batch instead of nine copy-pasted per-type queries. The tabs
-    // themselves say which listing types to count (including the combined
-    // `art|stickers` OR-group), so a tenth type is counted automatically — the
-    // hand-written `TAB_LISTING_TYPE` map this replaces was unguarded by any
-    // audit and already omitted art/stickers (Root Cause #61).
-    const [listingCounts, couponsCount, reviewsCount] = storeId
-        ? await Promise.all([
-            listingTabCounts(STORE_PAGE_TABS, { storeId }),
-            // audit-public-test-data-ok: a COUNT of the store's own coupons, and
-            // `CouponDocument` carries no isTestData field — there is nothing to strip.
-            couponsRepository
-                .list({ filters: sieveAnd(sieveFilter("storeId", SIEVE_OP.EQ, storeId), sieveFilter("validity.isActive", SIEVE_OP.EQ, "true")), page: 1, pageSize: 1 })
-                .then((r) => r.total)
-                .catch(() => 0),
-            reviewRepository
-                .listAll({ filters: sieveAnd(sieveFilter("storeId", SIEVE_OP.EQ, storeId), sieveFilter("status", SIEVE_OP.EQ, "approved")), page: 1, pageSize: 1 })
-                .then((r) => r.total)
-                .catch(() => 0),
-        ])
-        : [{}, 0, 0];
-    const visibleStoreTabs = STORE_PAGE_TABS.filter((tab) => {
-        if (tab.id === "bundles") {
-            if (!isCategoryTypeEnabled("bundle", settings))
-                return false;
-        }
-        else if (tab.id === pluginFor("art").tabSlug) {
-            // Combined tab — visible if either underlying listing type is enabled.
-            if (!(isListingTypeEnabled("art", settings) || isListingTypeEnabled("stickers", settings)))
-                return false;
-        }
-        else if (tab.listingType) {
-            if (!isListingTypeEnabled(tab.listingType, settings))
-                return false;
-        }
-        // A store with zero items of a given listing type shouldn't offer a tab
-        // that leads to an empty page — matches the "hide empty tab" rule below
-        // for coupons/reviews. `undefined` means the count query FAILED, not zero,
-        // so the tab stays visible rather than hiding real stock behind a
-        // swallowed error (Root Cause #59) — this used to be `.catch(() => 0)`.
-        const count = listingCounts[tab.id];
-        return count === undefined || count > 0;
-    });
-    const dropdownTabs = visibleStoreTabs.map((tab) => ({
-        value: tab.id,
-        label: tabLabel(tab.label, listingCounts[tab.id]),
-        href: STORE_LISTING_HREF[tab.id](storeSlug),
-    }));
-    const tabs = [
-        ...(couponsCount > 0
-            ? [{ value: "coupons", label: tabLabel("Coupons", couponsCount), href: String(ROUTES.PUBLIC.STORE_COUPONS(storeSlug)) }]
-            : []),
-        ...(reviewsCount > 0
-            ? [{ value: "reviews", label: tabLabel("Reviews", reviewsCount), href: String(ROUTES.PUBLIC.STORE_REVIEWS(storeSlug)) }]
-            : []),
-        { value: "about", label: "About", href: String(ROUTES.PUBLIC.STORE_ABOUT(storeSlug)) },
-    ];
+    // Single source of truth shared with the bare `/stores/[slug]` redirect
+    // (`getDefaultStoreTabPath`) — both need "which tabs actually have
+    // something in them, in what order", and computing that twice is the
+    // duplicated-predicate shape Root Cause #73 warns about.
+    const { dropdownTabs, tabs } = await resolveStoreTabs(storeSlug, storeId, settings);
     return (_jsxs(Main, { children: [_jsx(StoreHeader, { store: toStoreDetail(store), trust: trust }), _jsxs(Container, { size: "xl", className: "mt-6", children: [_jsx(StoreNavTabs, { dropdownTabs: dropdownTabs, dropdownPlaceholder: "Browse listings", tabs: tabs, activeValue: activeTab }), _jsx(Section, { padding: "t-lg", children: children })] })] }));
 }