@mohasinac/appkit 4.62.1 → 4.63.1

package/dist/features/dashboard/components/DashboardHubView.d.ts

@@ -0,0 +1,83 @@
+import React from "react";
+import type { AttentionCounts } from "../../../_internal/server/features/dashboard/attention";
+import type { DashboardHubSection } from "../../../_internal/shared/features/dashboard/hub-sections";
+/**
+ * The dashboard hub — one component, two modes, zero copy of its own.
+ *
+ * ## Why one component and not two
+ *
+ * A landing page lists SECTIONS; a section hub lists SCREENS. Those read as
+ * two features and are one: a grid of link cards, each with a title, a
+ * sentence about what it is for, and an optional count of things waiting. Same
+ * prop surface, same renderer — which the Duplication Framework calls a
+ * consolidate-on-sight ("copies accept the same parameters and return the same
+ * shape"), not a Rule-of-Three wait.
+ *
+ * The thing it must not become is `AdminGuideHubView`, which is the visual
+ * pattern here and hand-writes its own 13-card list — so a guide added to the
+ * nav never appears on it. Every card below comes from a nav item's existing
+ * `label` and `description`.
+ *
+ * ## Not a client component
+ *
+ * It takes plain data and renders. No hook, no fetch, no `"use client"` — the
+ * page that mounts it is already per-request (its layout reads the session), so
+ * the counts arrive with the render rather than costing a second invocation
+ * after it. See `_internal/server/features/dashboard/data.ts`.
+ *
+ * ## No icons, on purpose
+ *
+ * A nav item carries no `iconKey`, so icons would mean a hand-written map of
+ * 22 sections or ~130 screens — a second list to drift from the first, which is
+ * the whole defect this feature exists to avoid (Root Cause #61). The section
+ * heading plus the card's own sentence is the distinction; `<Badge>` carries
+ * the only signal that needs to catch the eye.
+ */
+export interface DashboardHubViewProps {
+    /**
+     * Page heading. Omit when the grid is embedded in a page that already has
+     * one — `/store` renders it inside a `CollapsibleSection`, and a second
+     * `<h1>` mid-page breaks the heading outline for a screen reader.
+     */
+    title?: string;
+    /** One sentence under the heading. Only rendered alongside a `title`. */
+    description?: string;
+    /**
+     * What to render.
+     *
+     * - `"sections"` — one card per section, linking to its hub. The landing page.
+     * - `"screens"` — one card per screen in `sections[0]`. A section hub.
+     *
+     * 🛑 A hub is passed a ONE-section array rather than a section plus a mode
+     * flag, so the two modes cannot disagree about what they are rendering.
+     */
+    mode: "sections" | "screens";
+    sections: DashboardHubSection[];
+    /** Built by the caller from `ROUTES.{PORTAL}.SECTION(slug)`. */
+    sectionHrefs: Record<string, string>;
+    counts: AttentionCounts;
+    /**
+     * Rendered above the cards — the live stat tiles on `/store` and `/user`.
+     *
+     * Those are real data and stay: the plan's "bland tile walls" are the
+     * undifferentiated grids of ~19 nav shortcuts, not the figures beside them.
+     * Deleting a working panel while replacing its neighbour is Root Cause #60's
+     * shape, so the slot exists and the caller keeps passing them.
+     */
+    above?: React.ReactNode;
+    /** Shown when the viewer can see nothing at all. */
+    emptyMessage?: string;
+    /**
+     * Render "7 screens" on a section card. Default `true`.
+     *
+     * 🛑 Pass `false` whenever `sections` has NOT been through every filter that
+     * applies to the portal. `/store` is the live case: its entitlement filter
+     * (`filterStoreNavGroups`) runs in the layout and on the hub pages, but the
+     * client landing does not hold the store document, so its "Listings" card
+     * would claim nine screens where the seller can reach six. The section itself
+     * is still correct — it is the COUNT that would over-promise, so the count is
+     * withheld rather than guessed.
+     */
+    showScreenCount?: boolean;
+}
+export declare function DashboardHubView({ title, description, mode, sections, sectionHrefs, counts, above, emptyMessage, showScreenCount, }: DashboardHubViewProps): React.JSX.Element;

package/dist/features/dashboard/components/DashboardHubView.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Alert, Badge, Div, Grid, Heading, Row, Section, Stack, Text, TextLink } from "../../../ui/index.js";
+/**
+ * Sum of the counts inside a section, or `null` when it has none.
+ *
+ * 🛑 `null` and `0` are different answers and a card renders only the first as
+ * "no badge". A section whose every count FAILED must not read as "nothing
+ * waiting" (Root Cause #72), so a failed read inside an otherwise-countless
+ * section stays `null` rather than collapsing to a sum of zero.
+ */
+function sectionTotal(section, counts) {
+    let total = null;
+    for (const item of section.items) {
+        const value = item.id ? counts[item.id] : undefined;
+        if (typeof value !== "number")
+            continue;
+        total = (total ?? 0) + value;
+    }
+    return total;
+}
+/** A count worth showing. Zero is not — a `0` badge is noise on every card. */
+function badgeFor(value) {
+    if (typeof value !== "number" || value <= 0)
+        return null;
+    return (_jsx(Badge, { variant: "warning", "aria-label": `${value} waiting`, children: value }));
+}
+function CardGrid({ cards }) {
+    return (_jsx(Grid, { cols: "cards", gap: "md", children: cards.map((card) => (_jsxs(TextLink, { variant: "bare", href: card.href, rounded: "xl", layout: "flex-col", gap: "sm", paddingX: "lg", paddingY: "lg", shadow: "hover-md", className: "group border border-[var(--appkit-color-border)] bg-[var(--appkit-color-surface)] hover:border-[var(--appkit-color-primary)] transition-all", children: [_jsxs(Row, { align: "center", justify: "between", gap: "sm", className: "min-w-0 w-full", children: [_jsx(Text, { weight: "semibold", className: "min-w-0 text-[var(--appkit-color-text)] group-hover:text-[var(--appkit-color-primary)] transition-colors", children: card.label }), badgeFor(card.count)] }), card.description && (_jsx(Text, { size: "sm", className: "text-[var(--appkit-color-text-muted)] leading-relaxed", children: card.description })), card.meta && (_jsx(Text, { size: "xs", className: "text-[var(--appkit-color-text-faint)] mt-auto", children: card.meta }))] }, card.key))) }));
+}
+export function DashboardHubView({ title, description, mode, sections, sectionHrefs, counts, above, emptyMessage, showScreenCount = true, }) {
+    const hasAny = sections.some((section) => section.items.length > 0);
+    return (_jsxs(Stack, { gap: "lg", children: [title && (_jsxs(Stack, { gap: "xs", children: [_jsx(Heading, { level: 1, size: "xl", weight: "semibold", color: "primary", children: title }), description && (_jsx(Text, { size: "sm", color: "muted", children: description }))] })), above, !hasAny && (_jsx(Alert, { variant: "info", title: "Nothing here yet", children: emptyMessage ??
+                    "Your permission set doesn't include access to any of these screens yet. Ask an admin for the permissions you need." })), hasAny && mode === "sections" && (_jsx(CardGrid, { cards: sections.map((section) => ({
+                    key: section.slug,
+                    href: sectionHrefs[section.slug] ?? "",
+                    label: section.title,
+                    /*
+                     * A section has no description of its own and must not invent one —
+                     * so it names what is inside it instead. `items.length` is the
+                     * post-filter count, which is what this viewer will actually find
+                     * PROVIDED every filter has run; see `showScreenCount`.
+                     */
+                    meta: showScreenCount
+                        ? `${section.items.length} ${section.items.length === 1 ? "screen" : "screens"}`
+                        : undefined,
+                    count: sectionTotal(section, counts),
+                })) })), hasAny &&
+                mode === "screens" &&
+                sections.map((section) => (_jsxs(Section, { children: [_jsx(Heading, { level: 2, size: "lg", weight: "semibold", className: "mb-4 text-[var(--appkit-color-text)]", children: section.title }), _jsx(CardGrid, { cards: section.items.map((item) => ({
+                                key: item.id ?? item.href,
+                                href: item.href,
+                                label: item.label,
+                                description: item.description,
+                                count: item.id ? (counts[item.id] ?? null) : null,
+                            })) })] }, section.slug))), hasAny && mode === "sections" && (_jsx(Div, { children: _jsx(Text, { size: "xs", color: "faint", children: "Every card above is a section of the sidebar. The screens inside one are the same screens, with a sentence each on what they are for." }) }))] }));
+}

package/dist/features/dashboard/components/DashboardSectionsClient.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import type { NavPortal, SidebarNavGroup } from "../../../_internal/shared/features/layout/types";
+export interface DashboardSectionsClientProps {
+    portal: NavPortal;
+    /**
+     * The portal's nav groups.
+     *
+     * 🛑 Pass the groups the SIDEBAR was given, already put through any
+     * portal-specific filter (`filterStoreNavGroups` for `/store`). This applies
+     * only the navConfig/permission filter; a section the store is not entitled
+     * to would otherwise appear here and nowhere else.
+     */
+    groups: readonly SidebarNavGroup[];
+    /** `null` means admin; `undefined` means "no permission gating applies". */
+    permissions?: string[] | null;
+    /** Omit when embedding in a page that already has a heading. */
+    title?: string;
+    description?: string;
+    /** Live stat tiles and anything else that belongs above the cards. */
+    above?: React.ReactNode;
+    emptyMessage?: string;
+}
+export declare function DashboardSectionsClient({ portal, groups, permissions, title, description, above, emptyMessage, }: DashboardSectionsClientProps): React.JSX.Element;

package/dist/features/dashboard/components/DashboardSectionsClient.js

@@ -0,0 +1,66 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { useSiteSettings } from "../../../core/hooks/useSiteSettings.js";
+import { filterNavGroups } from "../../../_internal/client/features/layout/filterNavItems.js";
+import { hubSections } from "../../../_internal/shared/features/dashboard/hub-sections.js";
+import { ROUTES } from "../../../next/routing/route-map.js";
+import { DashboardHubView } from "./DashboardHubView.js";
+/**
+ * The sectioned index of a dashboard, for a landing page that is already a
+ * CLIENT component.
+ *
+ * ## Why a client variant exists at all
+ *
+ * `/store/page.tsx` and `/user/page.tsx` are `"use client"` and carry live stat
+ * tiles (`useStoreDashboard`, `useNotifications`, an avatar uploader). Turning
+ * either into a server component to fetch hub data would mean moving a working
+ * 250–360 line page into a sibling file for the sake of a card grid — a large
+ * diff over a working feature, which is the shape of Root Cause #60.
+ *
+ * So the DATA source differs and the RENDERER does not: this resolves sections
+ * from the same `useSiteSettings` navConfig the sidebar reads, and hands them to
+ * the same `<DashboardHubView>` the admin landing renders server-side. One card
+ * grid, two ways in — not two card grids.
+ *
+ * ## 🛑 No attention counts here, and that is honest rather than lazy
+ *
+ * Counts need Firestore, which a client component can only reach through an
+ * endpoint — a second billed invocation per landing visit for numbers the page
+ * did not previously show (Root Cause #94). The admin landing, which is a
+ * server component under a session-reading layout, gets them for free in its
+ * own render. A seller's one countable figure (pending orders) is already a
+ * live stat tile on `/store`, so the badge would be the second place for it.
+ *
+ * `counts={{}}` means every card renders without a badge — never with a `0`,
+ * which is the one answer that would wrongly read as "nothing waiting"
+ * (Root Cause #72).
+ */
+/**
+ * 🛑 `Record<NavPortal, …>` so a fourth portal is a COMPILE error here rather
+ * than a landing page whose section cards all link to `""`. An object keyed on
+ * `string` would accept the omission silently (Root Cause #61).
+ */
+const SECTION_ROUTE = {
+    admin: (slug) => String(ROUTES.ADMIN.SECTION(slug)),
+    store: (slug) => String(ROUTES.STORE.SECTION(slug)),
+    user: (slug) => String(ROUTES.USER.SECTION(slug)),
+};
+export function DashboardSectionsClient({ portal, groups, permissions, title, description, above, emptyMessage, }) {
+    const { data: settings } = useSiteSettings();
+    /*
+     * Derived, never copied into state — the settings query can resolve after
+     * first paint, and a `useState` seeded from it would freeze the pre-settings
+     * answer. Same reasoning as `AdminIntegrationsView`.
+     */
+    const sections = useMemo(() => hubSections(filterNavGroups([...groups], settings?.navConfig, permissions)), [groups, settings?.navConfig, permissions]);
+    const sectionHrefs = useMemo(() => Object.fromEntries(sections.map((s) => [s.slug, SECTION_ROUTE[portal](s.slug)])), [sections, portal]);
+    return (_jsx(DashboardHubView, { title: title, description: description, mode: "sections", sections: sections, sectionHrefs: sectionHrefs, counts: {}, above: above, emptyMessage: emptyMessage, 
+        /*
+         * 🛑 Withheld deliberately. `/store`'s entitlement filter lives in the
+         * layout and on the hub pages, not here, so a count rendered from these
+         * groups would over-promise on the Listings card. See the prop's own
+         * header — the section is right, the number would not be.
+         */
+        showScreenCount: false }));
+}

package/dist/features/dispute-reasons/components/AdminDisputeReasonsView.d.ts

@@ -0,0 +1,55 @@
+import React from "react";
+import { type DisputeKind } from "../../../_internal/shared/features/orders/dispute-reasons";
+/**
+ * Admin → Trust & Safety → Dispute reasons.
+ *
+ * ## Why a management page exists at all
+ *
+ * Inline create in the triage drawer was the cheaper half and was rejected on
+ * its own, for a reason worth keeping: **with no management page nothing can
+ * ever retire a reason**, so the list only grows and a typo'd row is permanent.
+ * Both shipped — the drawer so an agent never leaves a ticket to add a missing
+ * reason, this page so the eleven seeded rows are reviewable and retire has a
+ * home.
+ *
+ * ## 🛑 A row is OPENABLE, not just actionable
+ *
+ * `audit-listing-detail-affordance` requires it and the reason is Root Cause
+ * #56: a menu of pure mutations lets staff act on a record they were never able
+ * to read. Here that would mean retiring a reason without seeing its KIND — and
+ * the kind is the only field that decides which gate the reason inherits, so
+ * retiring the wrong one silently narrows the wrong form.
+ *
+ * `RecordDetailModal` is the shared primitive for exactly this; a bespoke modal
+ * would have tripped the Duplication Framework's Rule of Three on sight.
+ */
+export interface AdminDisputeReasonsViewProps {
+    /**
+     * The staff list endpoint, supplied by the consumer.
+     *
+     * 🛑 A PROP rather than a literal in here, for the same reason
+     * `RaiseDisputeForm` takes `reasonsEndpoint`: appkit holds no consumer
+     * routes. The path belongs in `API_ROUTES`, which is the one registry, and a
+     * literal here would be a second place it is written — exactly what
+     * `audit-hardcoded-api-routes` blocks.
+     */
+    endpoint: string;
+    /** `PATCH /api/admin/dispute-reasons/{id}` with `{ isActive }`. */
+    onSetActive: (id: string, isActive: boolean) => Promise<void>;
+    /** `POST /api/dispute-reasons` — the same endpoint the triage drawer uses. */
+    onCreate: (input: {
+        label: string;
+        kind: DisputeKind;
+    }) => Promise<void>;
+}
+/**
+ * The two fields, exported so the triage drawer's inline create and this page
+ * cannot drift on the label bound or the kind vocabulary.
+ */
+export declare function DisputeReasonFields({ label, kind, onLabel, onKind, }: {
+    label: string;
+    kind: DisputeKind;
+    onLabel: (v: string) => void;
+    onKind: (v: DisputeKind) => void;
+}): React.JSX.Element;
+export declare function AdminDisputeReasonsView({ endpoint, onSetActive, onCreate, }: AdminDisputeReasonsViewProps): React.JSX.Element;

package/dist/features/dispute-reasons/components/AdminDisputeReasonsView.js

@@ -0,0 +1,175 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useState } from "react";
+import { Badge, Button, Row, Stack, Text } from "../../../ui/index.js";
+import { RecordDetailModal } from "../../../ui/components/RecordDetailModal.js";
+import { useToast } from "../../../ui/components/Toast.js";
+import { FieldInput } from "../../../ui/forms/FieldInput.js";
+import { FieldSelect } from "../../../ui/forms/FieldSelect.js";
+import { normalizeError } from "../../../errors/normalize.js";
+import { DataListingView } from "../../admin/components/DataListingView.js";
+import { ACTIONS } from "../../../_internal/shared/actions/action-registry.js";
+import { DISPUTE_KIND, } from "../../../_internal/shared/features/orders/dispute-reasons.js";
+import { DISPUTE_REASON_LABEL_MAX, } from "../schemas/firestore.js";
+/**
+ * What each kind MEANS, in one place.
+ *
+ * 🛑 A `Record<DisputeKind, string>`, so a third kind is a compile error here
+ * rather than a picker option rendering a bare token. The kind is the only
+ * field on a reason with a consequence — it decides which gate a dispute
+ * raised under it inherits — so it is the one that must never read as jargon.
+ */
+const KIND_MEANING = {
+    item: "Item problem — it arrived wrong or damaged",
+    not_reached: "Never arrived — the parcel did not reach the buyer",
+};
+/*
+ * Chips over `isActive`, as ordinary Sieve clauses. `listAll` applies no
+ * `isActive` filter of its own precisely so these work without the repository
+ * growing a method per chip.
+ *
+ * 🛑 "All" carries NO filter rather than `isActive==true|false`. A pipe-joined
+ * OR over a boolean would be two equalities merged for no reason, and — worse —
+ * it would exclude any row written before the field existed, which is the `!=`
+ * trap one step removed.
+ */
+const SCOPE_CHIPS = [
+    { id: "active", label: "Active", filter: "isActive==true" },
+    { id: "retired", label: "Retired", filter: "isActive==false" },
+    { id: "all", label: "All", filter: undefined },
+];
+/**
+ * The two fields, exported so the triage drawer's inline create and this page
+ * cannot drift on the label bound or the kind vocabulary.
+ */
+export function DisputeReasonFields({ label, kind, onLabel, onKind, }) {
+    return (_jsxs(Stack, { gap: "md", children: [_jsx(FieldInput, { name: "label", label: "Reason wording", required: true, value: label, onChange: onLabel, maxLength: DISPUTE_REASON_LABEL_MAX, placeholder: "The courier left it at the wrong flat" }), _jsx(FieldSelect, { name: "kind", label: "Kind", required: true, value: kind, onChange: (v) => onKind(v), 
+                /*
+                 * Two options, so `<FieldSelect>` is correct — `PaginatedSelect` is for
+                 * >5 (Rule #9), and a searchable dropdown over two values is worse than
+                 * a native select. Derived from the shipped union so a third kind
+                 * cannot exist in the gate and be missing here.
+                 */
+                options: DISPUTE_KIND.map((k) => ({ value: k, label: KIND_MEANING[k] })) })] }));
+}
+/** Create form. Shares `DisputeReasonFields` and the endpoint with the drawer. */
+function CreateReasonForm({ onSubmit, }) {
+    const [label, setLabel] = useState("");
+    const [kind, setKind] = useState(DISPUTE_KIND[0]);
+    const [busy, setBusy] = useState(false);
+    const { showToast } = useToast();
+    return (_jsxs(Stack, { gap: "md", children: [_jsx(Text, { size: "sm", color: "muted", children: "Short wording, as a buyer would read it. The detail goes in their own free-text field \u2014 this is a picker option, not the explanation." }), _jsx(DisputeReasonFields, { label: label, kind: kind, onLabel: setLabel, onKind: setKind }), _jsx(Button, { action: ACTIONS.ADMIN["add-dispute-reason"], isLoading: busy, disabled: busy || label.trim().length < 3, onClick: async () => {
+                    setBusy(true);
+                    try {
+                        await onSubmit({ label: label.trim(), kind });
+                    }
+                    catch (err) {
+                        void normalizeError(err);
+                        showToast("Couldn't add that reason.", "error");
+                    }
+                    finally {
+                        setBusy(false);
+                    }
+                } })] }));
+}
+export function AdminDisputeReasonsView({ endpoint, onSetActive, onCreate, }) {
+    const { showToast } = useToast();
+    const [open, setOpen] = useState(null);
+    const [pending, setPending] = useState(null);
+    const setActive = useCallback(async (row, isActive) => {
+        setPending(row.id);
+        try {
+            await onSetActive(row.id, isActive);
+            showToast(isActive ? `"${row.label}" is back in the picker.` : `"${row.label}" retired.`, "success");
+        }
+        catch (err) {
+            void normalizeError(err);
+            /*
+             * No optimistic flip anywhere here, so a failure needs no rollback —
+             * the row still shows what the server last told us. Only a successful
+             * write and the refetch behind it move the list.
+             */
+            showToast("Couldn't save that. Nothing was changed.", "error");
+        }
+        finally {
+            setPending(null);
+        }
+    }, [onSetActive, showToast]);
+    const rowControls = useCallback((row) => (_jsxs(Row, { align: "center", gap: "sm", children: [_jsx(Button, { variant: "ghost", size: "sm", onClick: () => setOpen(row), children: "View" }), _jsx(Button, { action: row.isActive
+                    ? ACTIONS.ADMIN["retire-dispute-reason"]
+                    : ACTIONS.ADMIN["reactivate-dispute-reason"], size: "sm", isLoading: pending === row.id, disabled: pending !== null, onClick: () => setActive(row, !row.isActive) })] })), [pending, setActive]);
+    return (_jsxs(_Fragment, { children: [_jsx(DataListingView, { config: {
+                    portal: "admin",
+                    title: "Dispute reasons",
+                    subtitle: "What buyers can pick when reporting a problem. A reason's kind decides which gate it inherits — the wording is yours.",
+                    endpoint: endpoint,
+                    queryKey: ["admin", "dispute-reasons"],
+                    defaultSort: "label",
+                    /*
+                     * 🛑 REQUIRED on `ListingViewConfig`, and the default must be one of
+                     * these or the dropdown opens with nothing selected (Root Cause #63).
+                     * Eleven rows, so the only orders worth offering are the buyer-facing
+                     * wording and which kind a reason belongs to.
+                     */
+                    sortOptions: [
+                        { value: "label", label: "Wording (A–Z)" },
+                        { value: "-label", label: "Wording (Z–A)" },
+                        { value: "kind", label: "Kind" },
+                    ],
+                    filterKeys: ["scope"],
+                    filterDefaults: { scope: "active" },
+                    buildFilters: (state) => SCOPE_CHIPS.find((c) => c.id === (state.scope ?? "active"))?.filter,
+                    mapRows: (res) => (res.items ?? []).map((r) => ({
+                        id: r.id,
+                        label: r.label,
+                        kind: r.kind,
+                        isActive: r.isActive,
+                        createdByName: r.createdByName,
+                    })),
+                    getTotal: (res, rows) => res.total ?? rows.length,
+                    /*
+                     * 🛑 No `searchPlaceholder` and no `search` — the endpoint does not read
+                     * `q`, and declaring either is what makes the box exist. ~39 views here
+                     * render a box whose endpoint ignores the term: it accepts typing, the
+                     * request carries it, and the results do not change, with no error
+                     * anywhere. Eleven rows with scope chips need no search.
+                     */
+                    emptyLabel: "No reasons in this scope.",
+                    primaryAction: {
+                        label: ACTIONS.ADMIN["add-dispute-reason"].label,
+                        onClick: ({ openCreatePanel }) => openCreatePanel(),
+                    },
+                    renderEditor: ({ closePanel }) => (_jsx(CreateReasonForm, { onSubmit: async (input) => {
+                            await onCreate(input);
+                            closePanel();
+                        } })),
+                    resolveEditorTitle: () => "Add a dispute reason",
+                    onRowClick: (row) => setOpen(row),
+                    renderRowActions: rowControls,
+                    renderCards: (rows) => (_jsx(Stack, { gap: "sm", children: rows.map((row) => (_jsxs(Row, { surface: "card", padding: "md", rounded: "lg", border: "default", align: "center", justify: "between", gap: "md", className: "min-w-0", children: [_jsxs(Stack, { gap: "xs", className: "min-w-0", children: [_jsxs(Row, { align: "center", gap: "sm", className: "min-w-0", children: [_jsx(Text, { weight: "semibold", color: "primary", className: "min-w-0", children: row.label }), _jsx(Badge, { variant: row.isActive ? "success" : "inactive", children: row.isActive ? "Active" : "Retired" })] }), _jsx(Text, { size: "xs", color: "muted", children: KIND_MEANING[row.kind] }), _jsxs(Text, { size: "xs", color: "faint", children: ["Added by ", row.createdByName] })] }), rowControls(row)] }, row.id))) })),
+                } }), open && (_jsx(RecordDetailModal, { isOpen: true, onClose: () => setOpen(null), title: open.label, badges: [
+                    {
+                        label: open.isActive ? "Active" : "Retired",
+                        variant: open.isActive ? "success" : "secondary",
+                    },
+                ], fields: [
+                    { label: "Buyer-facing wording", value: open.label },
+                    { label: "Kind", value: `${open.kind} — ${KIND_MEANING[open.kind]}` },
+                    {
+                        label: "State",
+                        value: open.isActive
+                            ? "Active — buyers see it on the dispute form"
+                            : "Retired — hidden from the form",
+                    },
+                    { label: "Added by", value: open.createdByName },
+                ], metadata: {
+                    id: open.id,
+                    /*
+                     * Stated on the record itself, because it is the fact an agent is
+                     * most likely to be unsure about at the moment they are deciding
+                     * whether to retire: the order snapshots the LABEL, so retiring
+                     * cannot rewrite what a past dispute said.
+                     */
+                    retiringIsNeverADelete: "Disputes already raised under this reason keep their wording — the order snapshots the label rather than pointing at this row.",
+                } }))] }));
+}

package/dist/features/dispute-reasons/repository/dispute-reasons.repository.d.ts

@@ -32,7 +32,31 @@ export declare class DisputeReasonsRepository extends BaseRepository<DisputeReas
         reason: DisputeReasonDocument;
         created: boolean;
     }>;
+    /**
+     * Every row, retired included — the staff management list.
+     *
+     * 🛑 Deliberately NOT `listActiveByKind` with the `isActive` clause dropped.
+     * That method also pins `kind`, and a management view must span both kinds:
+     * a reason retired for the wrong gate is exactly the row staff need to find.
+     *
+     * No `isActive` filter is applied here at all, so the caller's own Sieve
+     * filters decide — which is what lets the view offer Active / Retired / All
+     * chips without this method growing a parameter per chip.
+     */
+    listAll(model: SieveModel): Promise<FirebaseSieveResult<DisputeReasonDocument>>;
     /** Soft-retire. See the schema for why this is never a delete. */
     retire(id: string): Promise<void>;
+    /**
+     * Put a retired reason back in the picker.
+     *
+     * `createReason` already reactivates on a colliding re-add, which covers the
+     * agent who types the wording again. This covers the different case the
+     * management view creates: a row you can SEE and want back, where re-typing
+     * its exact label to resurrect it would be a trick rather than a control.
+     *
+     * The original `createdByName` is kept — they wrote the wording, and a
+     * reactivation is not authorship.
+     */
+    reactivate(id: string): Promise<void>;
 }
 export declare const disputeReasonsRepository: DisputeReasonsRepository;

package/dist/features/dispute-reasons/repository/dispute-reasons.repository.js

@@ -59,10 +59,38 @@ export class DisputeReasonsRepository extends BaseRepository {
         await this.createWithId(id, reason);
         return { reason, created: true };
     }
+    /**
+     * Every row, retired included — the staff management list.
+     *
+     * 🛑 Deliberately NOT `listActiveByKind` with the `isActive` clause dropped.
+     * That method also pins `kind`, and a management view must span both kinds:
+     * a reason retired for the wrong gate is exactly the row staff need to find.
+     *
+     * No `isActive` filter is applied here at all, so the caller's own Sieve
+     * filters decide — which is what lets the view offer Active / Retired / All
+     * chips without this method growing a parameter per chip.
+     */
+    async listAll(model) {
+        return this.sieveQuery(model, DisputeReasonsRepository.SIEVE_FIELDS, { baseQuery: this.getCollection(), defaultPageSize: 20, maxPageSize: 50 });
+    }
     /** Soft-retire. See the schema for why this is never a delete. */
     async retire(id) {
         await this.update(id, { isActive: false, updatedAt: new Date() });
     }
+    /**
+     * Put a retired reason back in the picker.
+     *
+     * `createReason` already reactivates on a colliding re-add, which covers the
+     * agent who types the wording again. This covers the different case the
+     * management view creates: a row you can SEE and want back, where re-typing
+     * its exact label to resurrect it would be a trick rather than a control.
+     *
+     * The original `createdByName` is kept — they wrote the wording, and a
+     * reactivation is not authorship.
+     */
+    async reactivate(id) {
+        await this.update(id, { isActive: true, updatedAt: new Date() });
+    }
 }
 DisputeReasonsRepository.SIEVE_FIELDS = {
     /*

package/dist/features/dispute-reasons/schemas/firestore.d.ts

@@ -22,10 +22,10 @@
  * should be able to add it without a release.
  */
 import type { DisputeKind } from "../../../_internal/shared/features/orders/dispute-reasons";
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
 export declare const DISPUTE_REASON_COLLECTION = "disputeReasons";
-export interface DisputeReasonDocument {
-    /** `dreason-<slug of label>`, so the same reason cannot be added twice. */
-    id: string;
+/** `id` is `dreason-<slug of label>`, so the same reason cannot be added twice. */
+export interface DisputeReasonDocument extends BaseDocument {
     /** Buyer-facing. Shown verbatim in the picker. */
     label: string;
     /** Which gate this reason is subject to. Never free-form. */
@@ -43,8 +43,6 @@ export interface DisputeReasonDocument {
     createdByName: string;
     /** The uid, for moderation. Never rendered. */
     createdByUid: string;
-    createdAt: Date;
-    updatedAt: Date;
 }
 export declare const DISPUTE_REASON_FIELDS: {
     readonly ID: "id";

package/dist/features/events/components/EventSaleBanner.js

@@ -16,5 +16,5 @@ export function EventSaleBanner({ discountPercent, couponCode, title, subtitle,
     const href = filterParam
         ? `${ROUTES.PUBLIC.PRODUCTS}?${encodeURIComponent(filterParam.key)}=${encodeURIComponent(filterParam.value)}`
         : `${ROUTES.PUBLIC.PRODUCTS}?onSale=true`;
-    return (_jsx(Section, { color: "inverse", tone: "accent-banner", className: `${__P.p6}`, rounded: "2xl", shadow: "lg", children: _jsxs(Stack, { gap: "md", children: [_jsxs(Stack, { gap: "xs", children: [_jsx(Heading, { level: 2, weight: "bold", size: "3xl", children: headline }), subtitle ? _jsx(Text, { color: "inverse-muted", size: "base", children: subtitle }) : null] }), couponCode ? (_jsxs(Div, { layout: "inline-flex", gap: "3", align: "center", className: "backdrop-blur", surface: "default", paddingY: "y-xs", paddingX: "x-md", rounded: "lg", children: [_jsx(Span, { size: "xs", className: "tracking-wide opacity-80", transform: "uppercase", children: "Code" }), _jsx(Span, { size: "lg", weight: "bold", className: "font-mono", children: couponCode })] })) : null, _jsx(Div, { children: _jsx(Link, { href: href, children: _jsx(Button, { variant: "secondary", children: "Shop the sale" }) }) })] }) }));
+    return (_jsx(Section, { color: "inverse", tone: "accent-banner", className: `${__P.p6}`, rounded: "2xl", shadow: "lg", children: _jsxs(Stack, { gap: "md", children: [_jsxs(Stack, { gap: "xs", children: [_jsx(Heading, { color: "inverse", variant: "none", level: 2, weight: "bold", size: "3xl", children: headline }), subtitle ? _jsx(Text, { color: "inverse-muted", size: "base", children: subtitle }) : null] }), couponCode ? (_jsxs(Div, { layout: "inline-flex", gap: "3", align: "center", className: "backdrop-blur", surface: "default", paddingY: "y-xs", paddingX: "x-md", rounded: "lg", children: [_jsx(Span, { size: "xs", className: "tracking-wide opacity-80", transform: "uppercase", children: "Code" }), _jsx(Span, { size: "lg", weight: "bold", className: "font-mono", children: couponCode })] })) : null, _jsx(Div, { children: _jsx(Link, { href: href, children: _jsx(Button, { variant: "secondary", children: "Shop the sale" }) }) })] }) }));
 }

package/dist/features/faq/components/FAQPageContent.js

@@ -45,12 +45,12 @@ export function FAQPageContent({ initialCategory = "all", categories, routeHelpe
                     total,
                     categoryCounts,
                     onSelect: handleCategorySelect,
-                }) }), _jsxs(Div, { layout: "grid", gap: "8", className: "grid-cols-1 lg:grid-cols-12", children: [_jsx(Div, { className: "hidden lg:col-span-4 lg:block xl:col-span-3", children: _jsx(FAQCategorySidebar, { selectedCategory: selectedCategory, onCategorySelect: handleCategorySelect, categoryCounts: categoryCounts, categories: categories, allFaqsHref: routeHelpers.allFaqsHref, categoryHref: routeHelpers.faqCategoryHref, contactHref: routeHelpers.contactHref, labels: {
+                }) }), _jsxs(Div, { layout: "grid", gap: "8", className: "lg:grid-cols-12", children: [_jsx(Div, { className: "hidden lg:col-span-4 lg:block xl:col-span-3", children: _jsx(FAQCategorySidebar, { selectedCategory: selectedCategory, onCategorySelect: handleCategorySelect, categoryCounts: categoryCounts, categories: categories, allFaqsHref: routeHelpers.allFaqsHref, categoryHref: routeHelpers.faqCategoryHref, contactHref: routeHelpers.contactHref, labels: {
                                 title: labels.categoriesTitle,
                                 allFaqs: labels.allFaqs,
                                 stillHaveQuestions: labels.stillHaveQuestions,
                                 contactSupport: labels.contactSupport,
-                            } }) }), _jsxs(Div, { className: "col-span-1 lg:col-span-8 xl:col-span-9", children: [_jsx(SlottedListingView, { portal: "public", inlineToolbar: true, className: "space-y-6", renderHeader: () => {
+                            } }) }), _jsxs(Div, { className: "lg:col-span-8 xl:col-span-9", children: [_jsx(SlottedListingView, { portal: "public", inlineToolbar: true, className: "space-y-6", renderHeader: () => {
                                     /*
                                      * The fuller answer, next to the short ones.
                                      *

package/dist/features/gateway-events/schemas/index.d.ts

@@ -44,13 +44,13 @@ export declare const gatewayEventFirestoreSchema: z.ZodObject<{
     terminal?: boolean | undefined;
     amount?: number | undefined;
     seedPurpose?: string | undefined;
+    payload?: Record<string, unknown> | undefined;
     orderIds?: string[] | undefined;
     processedAt?: Date | undefined;
     gatewayPaymentId?: string | undefined;
     gatewayOrderId?: string | undefined;
     providerEventId?: string | undefined;
     lastError?: string | undefined;
-    payload?: Record<string, unknown> | undefined;
     payloadTruncated?: boolean | undefined;
 }, {
     status: "received" | "failed" | "processed" | "processing" | "conflict" | "ignored";
@@ -69,13 +69,13 @@ export declare const gatewayEventFirestoreSchema: z.ZodObject<{
     terminal?: boolean | undefined;
     amount?: number | undefined;
     seedPurpose?: string | undefined;
+    payload?: Record<string, unknown> | undefined;
     orderIds?: string[] | undefined;
     processedAt?: Date | undefined;
     gatewayPaymentId?: string | undefined;
     gatewayOrderId?: string | undefined;
     providerEventId?: string | undefined;
     lastError?: string | undefined;
-    payload?: Record<string, unknown> | undefined;
     payloadTruncated?: boolean | undefined;
 }>;
 export type GatewayEventFromSchema = z.infer<typeof gatewayEventFirestoreSchema>;