@mohasinac/appkit 4.43.0 → 4.44.0

package/dist/features/tax-codes/schemas/firestore.js

@@ -0,0 +1,82 @@
+/**
+ * Tax codes — Firestore schema
+ *
+ * An HSN code and its GST rate, as an ENTITY rather than two fields repeated
+ * across every category. Changing a rate becomes one edit instead of ~330.
+ *
+ * ## 🛑 The reference is for AUTHORING. The scalars stay for CORRECTNESS.
+ *
+ * `CategoryProductDefaults.taxCodeId` points here, and `deriveTaxonomy`
+ * resolves it to `ProductDocument.gstRate` / `.hsnCode` **on the product**;
+ * the order item then snapshots from the product, exactly as it already does.
+ *
+ * That layering is not redundancy. Without it, editing a tax code would
+ * retroactively change the GST on orders already invoiced — a compliance
+ * problem, not a modelling preference. It is the same reason
+ * `OrderDocumentItem` already snapshots `hsnCode`/`gstRate`.
+ *
+ *   a category edit  -> changes future listings
+ *   a tax-code edit  -> changes future derivations
+ *   nothing          -> rewrites a past sale
+ *
+ * ## Why this exists at all
+ *
+ * GST has never been charged on goods here. Recorded in our own source
+ * (`_internal/server/features/checkout/actions.ts`): *"0 of 40 live orders had
+ * a `gstAmount`, and the order page's Tax row had never rendered."* And
+ * `gstRate` is set on zero of the current products.
+ *
+ * id === slug, prefix "tax-".
+ */
+export const TAX_CODES_COLLECTION = "taxCodes";
+export const TAX_CODE_PREFIX = "tax-";
+export const GST_RATE_VALUES = [0, 5, 12, 18, 28];
+export const TAX_CODE_UPDATABLE_FIELDS = [
+    "hsnCode",
+    "label",
+    "description",
+    "gstRate",
+    "chapter",
+    "effectiveFrom",
+    "isActive",
+    "notes",
+];
+export const TAX_CODE_FIELDS = {
+    ID: "id",
+    HSN_CODE: "hsnCode",
+    LABEL: "label",
+    GST_RATE: "gstRate",
+    CHAPTER: "chapter",
+    IS_ACTIVE: "isActive",
+    EFFECTIVE_FROM: "effectiveFrom",
+    CREATED_AT: "createdAt",
+    UPDATED_AT: "updatedAt",
+};
+export const TAX_CODE_SIEVE_FIELDS = {
+    label: { canFilter: true, canSort: true },
+    hsnCode: { canFilter: true, canSort: true },
+    gstRate: { canFilter: true, canSort: true },
+    chapter: { canFilter: true, canSort: false },
+    isActive: { canFilter: true, canSort: false },
+    createdAt: { canFilter: false, canSort: true },
+};
+/**
+ * Derive the document id from the HSN code.
+ *
+ * Deterministic, so a seed run is idempotent (Root Cause #25) and so the same
+ * HSN cannot be entered twice under two ids — which would give two rows one
+ * admin edits and the other serves.
+ */
+export function createTaxCodeId(hsnCode) {
+    const digits = hsnCode.replace(/\D/g, "");
+    return digits ? `${TAX_CODE_PREFIX}hsn-${digits}` : `${TAX_CODE_PREFIX}exempt-0`;
+}
+/**
+ * India's HSN codes are 4, 6 or 8 digits. Checked rather than trusted because
+ * the inline-create path in the seller form reaches the same route as the
+ * admin editor, and a malformed code propagates onto every product derived
+ * from the category that points at it.
+ */
+export function isValidHsnCode(hsnCode) {
+    return /^(\d{4}|\d{6}|\d{8})$/.test(hsnCode.trim());
+}

package/dist/features/tax-codes/schemas/tax-code-form.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+/** The GST slabs, as the rate select offers them. */
+export declare const GST_RATE_OPTIONS: {
+    value: string;
+    label: string;
+}[];
+/**
+ * Chapter options.
+ *
+ * 🛑 The two non-9503 chapters are offered because the merchandise exists
+ * (printed cards and stickers; playing cards), and their labels say the rate is
+ * unverified rather than implying one. Picking a chapter does not set a rate.
+ */
+export declare const HSN_CHAPTER_OPTIONS: {
+    value: string;
+    label: string;
+}[];
+/**
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one.
+ */
+export declare const taxCodeFormSchema: z.ZodEffects<z.ZodObject<{
+    label: z.ZodString;
+    hsnCode: z.ZodOptional<z.ZodString>;
+    gstRate: z.ZodEffects<z.ZodNumber, number, number>;
+    chapter: z.ZodOptional<z.ZodEnum<["9503", "4911", "9504", "exempt"]>>;
+    description: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    isActive: boolean;
+    gstRate: number;
+    description?: string | undefined;
+    notes?: string | undefined;
+    hsnCode?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+}, {
+    label: string;
+    isActive: boolean;
+    gstRate: number;
+    description?: string | undefined;
+    notes?: string | undefined;
+    hsnCode?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+}>, {
+    label: string;
+    isActive: boolean;
+    gstRate: number;
+    description?: string | undefined;
+    notes?: string | undefined;
+    hsnCode?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+}, {
+    label: string;
+    isActive: boolean;
+    gstRate: number;
+    description?: string | undefined;
+    notes?: string | undefined;
+    hsnCode?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+}>;
+export type TaxCodeFormValues = z.infer<typeof taxCodeFormSchema>;

package/dist/features/tax-codes/schemas/tax-code-form.js

@@ -0,0 +1,152 @@
+/*
+ * WHAT: The tax-code editor's schema — the field set, annotated for
+ *       `buildSectionsFromSchema`, with the HSN-format rule as a refinement
+ *       rather than a hint under the input.
+ *
+ * ## 🛑 Why the HSN rule is a refinement and not placeholder text
+ *
+ * A malformed HSN does not fail loudly. It propagates: a category points at
+ * the tax code, `deriveTaxonomy` writes `hsnCode` onto every product derived
+ * from that category, and the order item snapshots it onto a GST invoice.
+ * Nothing in that chain validates the string again, and the invoice is the
+ * first place a human might notice — by which point the sale is recorded.
+ *
+ * So the format is checked at the one place it enters the system. The same
+ * route serves the inline-create path in the seller form, which is the busiest
+ * surface and the one most likely to be used in a hurry.
+ *
+ * ## The exemption row is the reason `hsnCode` is not simply required
+ *
+ * A 0% row (live plants, live animals) has no HSN. Requiring one would force
+ * an author to invent a code to express an exemption, and an invented HSN on
+ * an invoice is exactly the failure above. So the refinement is conditional:
+ * blank is legal only at rate 0.
+ *
+ * 🛑 The two option arrays are exported for the VIEW to pass as
+ * `options: { gstRate: GST_RATE_OPTIONS, chapter: HSN_CHAPTER_OPTIONS }` —
+ * `FieldUiMeta` has no `options` key, and `annotate` would silently accept
+ * neither. That split follows `AdminBundleEditorView`, which supplies
+ * `BUNDLE_RULE_TYPE_OPTIONS` the same way: a select's VALUES are schema, its
+ * option list is often runtime data (brands, categories) and so belongs to
+ * whoever can fetch it.
+ *
+ * EXPORTS:
+ *   taxCodeFormSchema, type TaxCodeFormValues, GST_RATE_OPTIONS,
+ *   HSN_CHAPTER_OPTIONS
+ *
+ * @tag domain:tax-codes
+ * @tag layer:schema
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:AdminTaxCodeEditorView
+ * @tag sideEffects:none
+ */
+import { z } from "zod";
+import { annotate } from "../../shell/field-ui-meta";
+import { GST_RATE_VALUES, isValidHsnCode } from "./firestore";
+/** The GST slabs, as the rate select offers them. */
+export const GST_RATE_OPTIONS = GST_RATE_VALUES.map((r) => ({
+    value: String(r),
+    label: r === 0 ? "0% — exempt" : `${r}%`,
+}));
+/**
+ * Chapter options.
+ *
+ * 🛑 The two non-9503 chapters are offered because the merchandise exists
+ * (printed cards and stickers; playing cards), and their labels say the rate is
+ * unverified rather than implying one. Picking a chapter does not set a rate.
+ */
+export const HSN_CHAPTER_OPTIONS = [
+    { value: "9503", label: "9503 — Toys (verified)" },
+    { value: "4911", label: "4911 — Printed matter: cards, stickers, posters (rate unverified)" },
+    { value: "9504", label: "9504 — Playing cards, board games (rate unverified)" },
+    { value: "exempt", label: "Exempt — no HSN" },
+];
+/**
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one.
+ */
+export const taxCodeFormSchema = z
+    .object({
+    label: annotate(z
+        .string()
+        .min(1, "Give the code a label an admin will recognise in a picker.")
+        .max(150, "Keep the label under 150 characters."), {
+        section: "basics",
+        sectionLabel: "Tax code",
+        sectionRequired: true,
+        quick: true,
+        order: 1,
+        label: "Label",
+        help: 'What the picker shows, e.g. "Toys, non-electronic (HSN 9503 0020) — 5%".',
+    }),
+    /*
+     * A STRING, not a number: leading zeros are significant in an HSN code
+     * (`04` is not `4`) and a numeric input would eat them. Digits-only is
+     * enforced by the refinement below, against the real 4/6/8-digit rule.
+     */
+    hsnCode: annotate(z.string().trim().max(8, "An HSN code is at most 8 digits.").optional(), {
+        section: "basics",
+        quick: true,
+        order: 2,
+        row: "pair",
+        label: "HSN code",
+        help: "4, 6 or 8 digits. Leave blank only for a 0% exemption.",
+    }),
+    gstRate: annotate(z.coerce
+        .number()
+        .refine((v) => GST_RATE_VALUES.includes(v), {
+        message: "Pick one of the GST slabs: 0, 5, 12, 18 or 28.",
+    }), {
+        section: "basics",
+        sectionRequired: true,
+        quick: true,
+        order: 3,
+        row: "pair",
+        kind: "select",
+        label: "GST rate",
+    }),
+    chapter: annotate(z.enum(["9503", "4911", "9504", "exempt"]).optional(), {
+        section: "basics",
+        order: 4,
+        kind: "select",
+        label: "Chapter",
+        help: "Groups the picker. Only chapter 9503's rates are verified.",
+    }),
+    description: annotate(z.string().max(500).optional(), { section: "detail", sectionLabel: "Detail", order: 1, kind: "textarea", label: "Description" }),
+    notes: annotate(z.string().max(1000).optional(), {
+        section: "detail",
+        order: 2,
+        kind: "textarea",
+        label: "Notes",
+        help: "Why this rate, and what it covers. The thing a future admin will want.",
+    }),
+    isActive: annotate(z.boolean(), {
+        section: "detail",
+        order: 3,
+        label: "Active",
+        help: "An inactive code is never resolved onto a product, and disappears from the picker.",
+    }),
+})
+    .superRefine((values, ctx) => {
+    const hsn = values.hsnCode?.trim() ?? "";
+    // Blank is legal ONLY at 0%. See the header: forcing an HSN on an exemption
+    // is what gets a code invented, and an invented code reaches an invoice.
+    if (hsn === "") {
+        if (values.gstRate !== 0) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["hsnCode"],
+                message: "An HSN code is required for any rate above 0%. Leave it blank only to record an exemption.",
+            });
+        }
+        return;
+    }
+    if (!isValidHsnCode(hsn)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["hsnCode"],
+            message: "An HSN code must be exactly 4, 6 or 8 digits — no spaces or dots.",
+        });
+    }
+});

package/dist/features/tax-codes/schemas/tax-codes.validators.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Zod validators for the `/api/admin/tax-codes` route handlers.
+ *
+ * Separate from `tax-code-form.ts`, which is the EDITOR's schema: that one is
+ * annotated for `buildSectionsFromSchema`, takes strings from inputs, and
+ * coerces. These are the wire contracts, and they are `.strict()`.
+ *
+ * ## 🛑 `.strict()`, not `z.object()` and not `.passthrough()`
+ *
+ * `z.object()` STRIPS unknown keys, which is how a PATCH returns 200 having
+ * written nothing (Root Cause #40's shape, and the admin grouped-listings
+ * route's documented bug). `.passthrough()` writes whatever arrives, which is
+ * how a form overwrote booked lottery slots. `.strict()` 400s on a field the
+ * contract does not name — the caller is told, and nothing silently vanishes.
+ *
+ * ## The id is NOT accepted on update
+ *
+ * `createTaxCodeId` derives the id from the HSN code, so accepting an id (or
+ * re-deriving one on update) would let an edit orphan every
+ * `CategoryProductDefaults.taxCodeId` pointing at the old one — with a GST
+ * invoice at the end of that chain. To correct a wrong HSN: deactivate, create
+ * the right row, repoint the categories.
+ */
+import { z } from "zod";
+/**
+ * 🛑 `z.custom<GstRate>`, not `z.number().refine(...)`.
+ *
+ * A `.refine()` validates at runtime and does NOT narrow the inferred type —
+ * the payload still types as `number`, so `repository.create(body)` fails to
+ * compile against `gstRate: GstRate`, and the obvious unblock is a cast. A
+ * cast at a request boundary is where this codebase's worst bugs live (an
+ * `ActionResult` envelope spread as a product, a raw `StoreDocument` published
+ * as HTML), so the type is narrowed here instead.
+ *
+ * And `z.custom` rather than a hand-written `z.union([z.literal(0), …])`
+ * because the slab list then has ONE definition — `GST_RATE_VALUES`, which
+ * `ProductDocument.gstRate` and the form's option list also derive from. A
+ * literal union here would be a second enumeration of the same union, which is
+ * Root Cause #61's shape.
+ */
+export declare const GST_RATE_ENUM: z.ZodType<0 | 5 | 12 | 18 | 28, z.ZodTypeDef, 0 | 5 | 12 | 18 | 28>;
+export declare const HSN_CHAPTER_ENUM: z.ZodEnum<["9503", "4911", "9504", "exempt"]>;
+/**
+ * 🛑 `hsnCode` is OPTIONAL here and the blank-only-at-0% rule lives in the
+ * repository, not this schema. Deliberate: the same rule has to hold for the
+ * seed path and any future importer, neither of which goes through a Zod
+ * request schema. A rule enforced only at the HTTP edge is a rule with a side
+ * door.
+ */
+export declare const taxCodeCreateSchema: z.ZodObject<{
+    hsnCode: z.ZodDefault<z.ZodString>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    gstRate: z.ZodType<0 | 5 | 12 | 18 | 28, z.ZodTypeDef, 0 | 5 | 12 | 18 | 28>;
+    chapter: z.ZodOptional<z.ZodEnum<["9503", "4911", "9504", "exempt"]>>;
+    effectiveFrom: z.ZodOptional<z.ZodDate>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    label: string;
+    isActive: boolean;
+    gstRate: 0 | 5 | 12 | 18 | 28;
+    hsnCode: string;
+    description?: string | undefined;
+    notes?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+    effectiveFrom?: Date | undefined;
+}, {
+    label: string;
+    gstRate: 0 | 5 | 12 | 18 | 28;
+    description?: string | undefined;
+    isActive?: boolean | undefined;
+    notes?: string | undefined;
+    hsnCode?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+    effectiveFrom?: Date | undefined;
+}>;
+export type TaxCodeCreatePayload = z.infer<typeof taxCodeCreateSchema>;
+export declare const taxCodeUpdateSchema: z.ZodObject<{
+    hsnCode: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    gstRate: z.ZodOptional<z.ZodType<0 | 5 | 12 | 18 | 28, z.ZodTypeDef, 0 | 5 | 12 | 18 | 28>>;
+    chapter: z.ZodOptional<z.ZodEnum<["9503", "4911", "9504", "exempt"]>>;
+    effectiveFrom: z.ZodOptional<z.ZodDate>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    notes: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    label?: string | undefined;
+    description?: string | undefined;
+    isActive?: boolean | undefined;
+    notes?: string | undefined;
+    gstRate?: 0 | 5 | 12 | 18 | 28 | undefined;
+    hsnCode?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+    effectiveFrom?: Date | undefined;
+}, {
+    label?: string | undefined;
+    description?: string | undefined;
+    isActive?: boolean | undefined;
+    notes?: string | undefined;
+    gstRate?: 0 | 5 | 12 | 18 | 28 | undefined;
+    hsnCode?: string | undefined;
+    chapter?: "9503" | "4911" | "9504" | "exempt" | undefined;
+    effectiveFrom?: Date | undefined;
+}>;
+export type TaxCodeUpdatePayload = z.infer<typeof taxCodeUpdateSchema>;

package/dist/features/tax-codes/schemas/tax-codes.validators.js

@@ -0,0 +1,85 @@
+/**
+ * Zod validators for the `/api/admin/tax-codes` route handlers.
+ *
+ * Separate from `tax-code-form.ts`, which is the EDITOR's schema: that one is
+ * annotated for `buildSectionsFromSchema`, takes strings from inputs, and
+ * coerces. These are the wire contracts, and they are `.strict()`.
+ *
+ * ## 🛑 `.strict()`, not `z.object()` and not `.passthrough()`
+ *
+ * `z.object()` STRIPS unknown keys, which is how a PATCH returns 200 having
+ * written nothing (Root Cause #40's shape, and the admin grouped-listings
+ * route's documented bug). `.passthrough()` writes whatever arrives, which is
+ * how a form overwrote booked lottery slots. `.strict()` 400s on a field the
+ * contract does not name — the caller is told, and nothing silently vanishes.
+ *
+ * ## The id is NOT accepted on update
+ *
+ * `createTaxCodeId` derives the id from the HSN code, so accepting an id (or
+ * re-deriving one on update) would let an edit orphan every
+ * `CategoryProductDefaults.taxCodeId` pointing at the old one — with a GST
+ * invoice at the end of that chain. To correct a wrong HSN: deactivate, create
+ * the right row, repoint the categories.
+ */
+import { z } from "zod";
+import { GST_RATE_VALUES } from "./firestore";
+const LABEL_MAX = 150;
+const DESCRIPTION_MAX = 500;
+const NOTES_MAX = 1000;
+/**
+ * 🛑 `z.custom<GstRate>`, not `z.number().refine(...)`.
+ *
+ * A `.refine()` validates at runtime and does NOT narrow the inferred type —
+ * the payload still types as `number`, so `repository.create(body)` fails to
+ * compile against `gstRate: GstRate`, and the obvious unblock is a cast. A
+ * cast at a request boundary is where this codebase's worst bugs live (an
+ * `ActionResult` envelope spread as a product, a raw `StoreDocument` published
+ * as HTML), so the type is narrowed here instead.
+ *
+ * And `z.custom` rather than a hand-written `z.union([z.literal(0), …])`
+ * because the slab list then has ONE definition — `GST_RATE_VALUES`, which
+ * `ProductDocument.gstRate` and the form's option list also derive from. A
+ * literal union here would be a second enumeration of the same union, which is
+ * Root Cause #61's shape.
+ */
+export const GST_RATE_ENUM = z.custom((v) => typeof v === "number" && GST_RATE_VALUES.includes(v), { message: "gstRate must be one of 0, 5, 12, 18 or 28." });
+export const HSN_CHAPTER_ENUM = z.enum(["9503", "4911", "9504", "exempt"]);
+/**
+ * 🛑 `hsnCode` is OPTIONAL here and the blank-only-at-0% rule lives in the
+ * repository, not this schema. Deliberate: the same rule has to hold for the
+ * seed path and any future importer, neither of which goes through a Zod
+ * request schema. A rule enforced only at the HTTP edge is a rule with a side
+ * door.
+ */
+export const taxCodeCreateSchema = z
+    .object({
+    /*
+     * Omitted becomes `""`, not `undefined`, because `TaxCodeDocument.hsnCode`
+     * is REQUIRED and the exemption row's value genuinely is the empty string.
+     * An optional-into-required field here would force a cast at the one call
+     * site, and "no HSN" and "nobody filled this in" would become
+     * indistinguishable — exactly the `undefined`-vs-`0` distinction `gstRate`
+     * depends on, one field over.
+     */
+    hsnCode: z.string().trim().max(8).default(""),
+    label: z.string().trim().min(1).max(LABEL_MAX),
+    description: z.string().max(DESCRIPTION_MAX).optional(),
+    gstRate: GST_RATE_ENUM,
+    chapter: HSN_CHAPTER_ENUM.optional(),
+    effectiveFrom: z.coerce.date().optional(),
+    isActive: z.boolean().default(true),
+    notes: z.string().max(NOTES_MAX).optional(),
+})
+    .strict();
+export const taxCodeUpdateSchema = z
+    .object({
+    hsnCode: z.string().trim().max(8).optional(),
+    label: z.string().trim().min(1).max(LABEL_MAX).optional(),
+    description: z.string().max(DESCRIPTION_MAX).optional(),
+    gstRate: GST_RATE_ENUM.optional(),
+    chapter: HSN_CHAPTER_ENUM.optional(),
+    effectiveFrom: z.coerce.date().optional(),
+    isActive: z.boolean().optional(),
+    notes: z.string().max(NOTES_MAX).optional(),
+})
+    .strict();

package/dist/features/tester/actions/index.d.ts

@@ -1,2 +1 @@
 export * from "./checklist-item-actions";
-export * from "./leaderboard-actions";

package/dist/features/tester/actions/index.js

@@ -1,2 +1 @@
 export * from "./checklist-item-actions";
-export * from "./leaderboard-actions";

package/dist/features/tester/components/AdminTesterFeedbackIssuesView.js

@@ -4,7 +4,7 @@ import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { Button, Card, Details, Div, Row, Stack, Summary, Text } from "../../../ui";
 import { MediaImage } from "../../media/MediaImage";
 import { apiClient } from "../../../http";
-import { useApiMutation } from "../../../client";
+import { useApiMutation } from "../../../client/api/useApiMutation";
 import { ADMIN_ENDPOINTS } from "../../../constants/api-endpoints";
 import { ACTIONS } from "../../../_internal/shared/actions/action-registry";
 const REPORT_QUERY_KEY = ["admin", "tester-feedback", "report"];

package/dist/features/tester/components/AdminTesterFeedbackListView.js

@@ -1,6 +1,6 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useApiMutation } from "../../../client";
+import { useApiMutation } from "../../../client/api/useApiMutation";
 import { SIEVE_OP, sieveFilter } from "../../../utils/sieve-builder";
 import { sortBy } from "../../../constants/sort";
 import { TESTER_CHECKLIST_RESPONSE_FIELDS } from "../schemas/firestore";

package/dist/features/tester/components/index.d.ts

@@ -1,5 +1,3 @@
-export { TesterHubView } from "./TesterHubView";
-export type { TesterHubViewProps } from "./TesterHubView";
 export { TesterChecklistStepRow } from "./TesterChecklistStepRow";
 export type { TesterChecklistStepRowProps, TesterChecklistStepItem } from "./TesterChecklistStepRow";
 export { TesterFeedbackChart } from "./TesterFeedbackChart";
@@ -9,5 +7,3 @@ export { AdminTesterFeedbackReportView } from "./AdminTesterFeedbackReportView";
 export { AdminTesterFeedbackIssuesView } from "./AdminTesterFeedbackIssuesView";
 export { AdminTesterFeedbackListView } from "./AdminTesterFeedbackListView";
 export type { AdminTesterFeedbackListViewProps } from "./AdminTesterFeedbackListView";
-export { BugHunterLeaderboardView } from "./BugHunterLeaderboardView";
-export type { BugHunterLeaderboardViewProps } from "./BugHunterLeaderboardView";

package/dist/features/tester/components/index.js

@@ -1,8 +1,6 @@
-export { TesterHubView } from "./TesterHubView";
 export { TesterChecklistStepRow } from "./TesterChecklistStepRow";
 export { TesterFeedbackChart } from "./TesterFeedbackChart";
 export { AdminTesterFeedbackView } from "./AdminTesterFeedbackView";
 export { AdminTesterFeedbackReportView } from "./AdminTesterFeedbackReportView";
 export { AdminTesterFeedbackIssuesView } from "./AdminTesterFeedbackIssuesView";
 export { AdminTesterFeedbackListView } from "./AdminTesterFeedbackListView";
-export { BugHunterLeaderboardView } from "./BugHunterLeaderboardView";

package/dist/features/tester/repository/tester-checklist-item.repository.d.ts

@@ -1,6 +1,6 @@
 import { BaseRepository } from "../../../providers/db-firebase";
 import type { FirebaseSieveFields, FirebaseSieveResult, SieveModel } from "../../../providers/db-firebase";
-import { type TesterChecklistItemDocument, type TesterChecklistItemCreateInput, type TesterChecklistItemUpdateInput, type BugHunterLeaderboardEntry } from "../schemas/firestore";
+import { type TesterChecklistItemDocument, type TesterChecklistItemCreateInput, type TesterChecklistItemUpdateInput } from "../schemas/firestore";
 export declare class TesterChecklistItemRepository extends BaseRepository<TesterChecklistItemDocument> {
     static readonly SIEVE_FIELDS: FirebaseSieveFields;
     constructor();
@@ -15,24 +15,5 @@ export declare class TesterChecklistItemRepository extends BaseRepository<Tester
     /** Reopens a fixed, bug-confirmed case as a new, active version for retest.
      * The old item stays disabled forever with its bug-hunter credit intact. */
     reopenAsNewVersion(oldItemId: string): Promise<TesterChecklistItemDocument>;
-    /**
-     * Ids of automated (non-human) accounts, excluded from the PUBLIC leaderboard.
-     *
-     * Read as a bare collection query rather than through `userRepository` on purpose:
-     * no repository in this codebase imports another, and this needs a key set, not
-     * user documents. `.select()` with no fields returns refs only, so the read is as
-     * cheap as Firestore allows, and `isBot == true` is a single-field equality served
-     * by the automatic index — no composite index to declare.
-     */
-    private botHunterIds;
-    /** Single-query, in-memory aggregation of bug credits per hunter — mirrors
-     * EventEntryRepository.getLeaderboard()'s shape. Includes old/disabled/
-     * superseded items, since bug credit is permanent.
-     *
-     * Bot accounts are aggregated out (not merely ranked last): the board exists to
-     * credit people, and a runner working all 943 cases would otherwise dominate it.
-     * The credit still lives on the item, so admin triage and the item's own
-     * `bugHunterName` are unaffected. */
-    getBugHunterLeaderboard(limit?: number): Promise<BugHunterLeaderboardEntry[]>;
 }
 export declare const testerChecklistItemRepository: TesterChecklistItemRepository;

package/dist/features/tester/repository/tester-checklist-item.repository.js

@@ -1,7 +1,6 @@
 import { BaseRepository, parseSieveDateValue } from "../../../providers/db-firebase";
 import { buildSearchTxt } from "../../../utils/search-txt";
 import { DatabaseError } from "../../../errors";
-import { USER_COLLECTION } from "../../auth/schemas/firestore";
 import { TESTER_CHECKLIST_ITEM_COLLECTION, TESTER_CHECKLIST_ITEM_FIELDS, createChecklistItemId, } from "../schemas/firestore";
 export class TesterChecklistItemRepository extends BaseRepository {
     constructor() {
@@ -87,57 +86,6 @@ export class TesterChecklistItemRepository extends BaseRepository {
         await this.update(old.id, { supersededByItemId: newId });
         return newItem;
     }
-    /**
-     * Ids of automated (non-human) accounts, excluded from the PUBLIC leaderboard.
-     *
-     * Read as a bare collection query rather than through `userRepository` on purpose:
-     * no repository in this codebase imports another, and this needs a key set, not
-     * user documents. `.select()` with no fields returns refs only, so the read is as
-     * cheap as Firestore allows, and `isBot == true` is a single-field equality served
-     * by the automatic index — no composite index to declare.
-     */
-    async botHunterIds() {
-        const snapshot = await this.db
-            .collection(USER_COLLECTION)
-            .where("isBot", "==", true)
-            .select()
-            .get();
-        return new Set(snapshot.docs.map((d) => d.id));
-    }
-    /** Single-query, in-memory aggregation of bug credits per hunter — mirrors
-     * EventEntryRepository.getLeaderboard()'s shape. Includes old/disabled/
-     * superseded items, since bug credit is permanent.
-     *
-     * Bot accounts are aggregated out (not merely ranked last): the board exists to
-     * credit people, and a runner working all 943 cases would otherwise dominate it.
-     * The credit still lives on the item, so admin triage and the item's own
-     * `bugHunterName` are unaffected. */
-    async getBugHunterLeaderboard(limit = 50) {
-        const [snapshot, botIds] = await Promise.all([
-            this.db
-                .collection(this.collection)
-                .where(TESTER_CHECKLIST_ITEM_FIELDS.BUG_CONFIRMED, "==", true)
-                .get(),
-            this.botHunterIds(),
-        ]);
-        const byHunter = new Map();
-        for (const doc of snapshot.docs) {
-            const item = this.mapDoc(doc);
-            if (!item.bugHunterId || botIds.has(item.bugHunterId))
-                continue;
-            const entry = byHunter.get(item.bugHunterId) ?? {
-                name: item.bugHunterName ?? "Unknown tester",
-                count: 0,
-            };
-            entry.count += 1;
-            byHunter.set(item.bugHunterId, entry);
-        }
-        return Array.from(byHunter.entries())
-            .map(([hunterId, v]) => ({ hunterId, hunterName: v.name, bugCount: v.count }))
-            .sort((a, b) => b.bugCount - a.bugCount)
-            .slice(0, limit)
-            .map((entry, index) => ({ ...entry, rank: index + 1 }));
-    }
 }
 TesterChecklistItemRepository.SIEVE_FIELDS = {
     groupKey: { canFilter: true, canSort: true },

package/dist/features/tester/schemas/firestore.d.ts

@@ -164,12 +164,6 @@ export declare const testerChecklistItemQueryHelpers: {
     readonly active: () => readonly ["isActive", "==", true];
     readonly confirmedBugs: () => readonly ["bugConfirmed", "==", true];
 };
-export interface BugHunterLeaderboardEntry {
-    rank: number;
-    hunterId: string;
-    hunterName: string;
-    bugCount: number;
-}
 export declare function slugifyChecklistLabel(label: string): string;
 export declare function createChecklistItemId(groupKey: string, pageKey: string, label: string): string;
 /**