@mohasinac/appkit 4.52.4 → 4.53.0

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

@@ -0,0 +1,248 @@
+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;
+}
+/**
+ * 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/StoreNavTabs.js

@@ -1,7 +1,7 @@
 "use client";
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { useRouter } from "next/navigation.js";
-import { TabBarButton, TabBarShell, TabsNavSelect, TextLink } from "../../../ui/index.js";
+import { OverflowRow, TabBarButton, TabBarShell, TextLink } from "../../../ui/index.js";
 export function StoreNavTabs({ tabs, dropdownTabs = [], dropdownPlaceholder = "Browse listings", activeValue, onTabChange, renderTabBar, className = "", }) {
     const router = useRouter();
     const handleChange = (v) => onTabChange?.(v);
@@ -25,7 +25,22 @@ export function StoreNavTabs({ tabs, dropdownTabs = [], dropdownPlaceholder = "B
      * the wrong element for sizing utilities (Root Cause #29); those now live
      * on `.appkit-tabs-dropdown` in Tabs.style.css.
      */
-    const leading = dropdownTabs.length > 0 ? (_jsx(TabsNavSelect, { ariaLabel: dropdownPlaceholder, options: dropdownTabs.map((tab) => ({ value: tab.value, label: tab.label })), value: activeDropdownTab?.value ?? "", placeholder: activeDropdownTab ? undefined : dropdownPlaceholder, selected: Boolean(activeDropdownTab), onValueChange: handleDropdownChange })) : undefined;
+    /*
+     * `alwaysCollapsed` — this one is a dropdown BY DESIGN, not by measurement.
+     * It is the listing-type picker, deliberately collapsed however much room
+     * the bar has, so adding a tenth listing type can never push the store's
+     * Reviews and About tabs off the edge. That is a product decision about what
+     * belongs in a row, which no width measurement can make.
+     *
+     * It replaced a native `<select>`, so it is now searchable and keyboard
+     * navigable — which matters here because the option set grows with every
+     * listing type the platform adds.
+     */
+    const leading = dropdownTabs.length > 0 ? (_jsx(OverflowRow, { items: dropdownTabs.map((tab) => ({
+            id: tab.value,
+            label: tab.label,
+            onSelect: () => handleDropdownChange(tab.value),
+        })), ariaLabel: dropdownPlaceholder, activeId: activeDropdownTab?.value, placeholder: dropdownPlaceholder, searchPlaceholder: "Search listing types\u2026", alwaysCollapsed: true })) : undefined;
     /*
      * Triggers carry `.appkit-tabs-trigger` and NOTHING else — no padding /
      * size / weight props, no conditional colour classes. `important: true` is

package/dist/features/stores/manifest.js

@@ -4,10 +4,14 @@ export const manifest = {
     envKeys: [],
     routes: [
         { segment: "[locale]/stores", exports: { default: "StoresIndexPageView" } },
-        {
-            segment: "[locale]/stores/[storeSlug]",
-            exports: { default: "StoreStorefrontView" },
-        },
+        /*
+         * `[locale]/stores/[storeSlug]` is deliberately ABSENT. It is a bare
+         * `redirect()` to the products tab and renders no view at all, so there is
+         * no appkit export to name — and naming one is exactly how
+         * `StoreStorefrontView` (an alias of the orphaned `SellerStoreView` slot
+         * shell) kept reading as wired for as long as it did. The storefront chrome
+         * lives in the segment's own layout; the tabs below are the real views.
+         */
         {
             segment: "[locale]/stores/[storeSlug]/products",
             exports: { default: "StoreProductsView" },

package/dist/features/support/repository/support.repository.d.ts

@@ -1,8 +1,7 @@
 import { BaseRepository } from "../../../providers/db-firebase";
 import type { FirebaseSieveFields, FirebaseSieveResult, SieveModel } from "../../../providers/db-firebase";
 import type { JsonValue } from "../../../schemas/types";
-import type { DocumentSnapshot } from "firebase-admin/firestore";
-import { type SupportTicketDocument, type SupportTicketCreateInput, type SupportTicketUpdateInput, type TicketMessage, type TicketStatus } from "../schemas/firestore";
+import { type SupportTicketDocument, type SupportTicketPlain, type SupportTicketCreateInput, type SupportTicketUpdateInput, type TicketMessage, type TicketStatus } from "../schemas/firestore";
 import { type HistoryActor } from "../../../_internal/shared/history/index";
 /** Who/why for a write that lands in `statusHistory`. */
 export interface TicketWriteContext {
@@ -33,7 +32,19 @@ export declare class SupportRepository extends BaseRepository<SupportTicketDocum
      */
     protected buildSearchTxtFor(data: Record<string, JsonValue>): string[] | null;
     /** Decrypt on read so callers see the shape they wrote. */
-    protected mapDoc<D = SupportTicketDocument>(snap: DocumentSnapshot): D;
+    /** Plaintext PII. **Opt-in and named** — shows up in review and in a grep. */
+    revealTicket(doc: SupportTicketDocument): SupportTicketPlain;
+    /** As `revealTicket`, for a list read. */
+    revealTickets(docs: readonly SupportTicketDocument[]): SupportTicketPlain[];
+    /**
+     * Masked PII — **the default for any surface that only needs to identify a
+     * row to a human.** Decrypts first, then masks: the mask helpers refuse
+     * ciphertext by design, so passing a stored field straight in would return
+     * "Anonymous" for every row.
+     */
+    maskedTicket(doc: SupportTicketDocument): SupportTicketPlain;
+    /** As `maskedTicket`, for a list read. */
+    maskedTickets(docs: readonly SupportTicketDocument[]): SupportTicketPlain[];
     createTicket(input: SupportTicketCreateInput): Promise<SupportTicketDocument>;
     getUserTickets(userId: string, page?: number, pageSize?: number): Promise<FirebaseSieveResult<SupportTicketDocument>>;
     /**