@mohasinac/appkit 4.43.0 → 4.45.0

package/scripts/seed-cli.mjs

@@ -195,7 +195,7 @@ const {
   siteSettingsSeedData, faqSeedData,
   wishlistsSeedData, historySeedData,
   groupedListingsSeedData,
-  scammersSeedData, productFeaturesSeedData,
+  scammersSeedData, productFeaturesSeedData, taxCodesSeedData,
   testerChecklistSeedData, testerResponsesSeedData,
   supportTicketsSeedData, catalogueSeedData,
   shipmentsSeedData, shipmentLotsSeedData, shipmentItemsSeedData,
@@ -210,6 +210,7 @@ const {
   CART_COLLECTION,
   GROUPED_LISTINGS_COLLECTION, SCAMMER_COLLECTION,
   WISHLIST_COLLECTION, HISTORY_COLLECTION, PRODUCT_FEATURES_COLLECTION,
+  TAX_CODES_COLLECTION,
   TESTER_CHECKLIST_ITEM_COLLECTION,
   TESTER_CHECKLIST_RESPONSE_COLLECTION,
   // PII field/index constants (plain data, still in the main barrel — the
@@ -219,6 +220,16 @@ const {
   REVIEW_PII_FIELDS, OFFER_PII_FIELDS, EVENT_ENTRY_PII_FIELDS,
   // misc
   generateFAQId,
+  /*
+   * Seed provenance. `stampSeedPurpose` is the ONE place a `seedPurpose` (and
+   * the `isTestData` / `testDataExpiresAt` derived from it) is produced, shared
+   * with `seed/runner.ts` so the two loaders cannot disagree about what a
+   * purpose means — Root Cause #75's shape on the seed axis.
+   */
+  stampSeedPurpose,
+  resolveSeedPurpose,
+  SEED_COLLECTION_PURPOSE,
+  ALL_SEED_PURPOSES,
 } = appkit;
 
 // ---------------------------------------------------------------------------
@@ -285,6 +296,7 @@ const COLLECTION_MAP = {
   groupedListings: GROUPED_LISTINGS_COLLECTION,
   scammerProfiles: SCAMMER_COLLECTION,
   productFeatures: PRODUCT_FEATURES_COLLECTION,
+  taxCodes: TAX_CODES_COLLECTION,
   testerChecklistItems: TESTER_CHECKLIST_ITEM_COLLECTION,
   /*
    * Tester submissions. DERIVED tier in the tester's own map (wiped at setup so
@@ -370,6 +382,7 @@ const SEED_DATA_MAP = {
   groupedListings: groupedListingsSeedData,
   scammerProfiles: scammersSeedData,
   productFeatures: productFeaturesSeedData,
+  taxCodes: taxCodesSeedData,
   testerChecklistItems: testerChecklistSeedData,
   testerChecklistResponses: testerResponsesSeedData,
 };
@@ -575,7 +588,22 @@ async function loadUsers(seed, stats) {
       // The previous form relied on ordering alone (indices first, THEN
       // encrypt) — correct, but one line-swap away from spreading plaintext
       // back over ciphertext, which is why `addPiiIndices` no longer exists.
-      const plain = stripUndefined({ ...u });
+      /*
+       * 🛑 Provenance is stamped here too, and `users` is the collection the
+       * whole scheme exists for.
+       *
+       * It had no permanence marker of any kind, so a seeded persona could not
+       * be told apart from a real signup — and a seeded user is the most
+       * expensive thing to delete wrongly: it owns an **Auth record**, a
+       * `userSlugs` index entry, addresses, a cart, orders, bids and reviews,
+       * and `users` sits in the tester harness's PRESERVE tier precisely
+       * because a wrong sweep there is the only permanent damage a run can do.
+       *
+       * Stamped before the PII pass so `plain` carries it: the indices are
+       * hashed from plaintext and the encryption must not see a hashed value,
+       * so nothing may be added to `docData` after that pair runs.
+       */
+      const plain = stripUndefined(stampSeedPurpose("users", { ...u }, LOAD_STARTED_AT));
       let docData = {
         ...encryptPiiFields(plain, [...USER_PII_FIELDS]),
         ...piiIndicesFor(plain, USER_PII_INDEX_MAP),
@@ -600,7 +628,15 @@ async function loadSubcollection(seed, parentColl, parentKey, subColl, idKey, pi
       if (!parent || !id) { stats.errors++; continue; }
       const { [parentKey]: _p, [idKey]: _i, ...data } = d;
       const docRef = db.collection(parentColl).doc(parent).collection(subColl).doc(id);
-      const payload = piiFields ? encryptPiiFields(stripUndefined(data), [...piiFields]) : stripUndefined(data);
+      /*
+       * Subcollection rows inherit the SUBCOLLECTION's purpose, not the
+       * parent's — `subColl` is the key in `SEED_COLLECTION_PURPOSE`. A
+       * `couponUsage` row under a permanent user is still its own record, and
+       * conflating the two would make a parent's classification silently
+       * govern children it knows nothing about.
+       */
+      const stamped = stripUndefined(stampSeedPurpose(subColl, data, LOAD_STARTED_AT));
+      const payload = piiFields ? encryptPiiFields(stamped, [...piiFields]) : stamped;
       await docRef.set(payload, { merge: true });
       stats.created++;
     } catch (err) { console.error(`    ✗ ${err.message}`); stats.errors++; }
@@ -612,8 +648,25 @@ async function loadOneDocPerUser(seed, coll, stats) {
     try {
       const { id, userId, items, updatedAt } = d;
       if (!id || !userId) { stats.errors++; continue; }
+      /*
+       * 🛑 `merge: false` — this loader REPLACES the document, which is correct
+       * for a wishlist or a history list (the array IS the record), and is
+       * exactly why the stamp has to be inside the payload rather than added
+       * by a later merge-write that would be wiped on the next load.
+       *
+       * `coll` is the real Firestore collection name here rather than the seed
+       * key, and for `wishlists`/`history` the two are identical — the only two
+       * callers. `resolveSeedPurpose` falls back to `permanent` if that ever
+       * stops being true, which is the safe direction.
+       */
       await db.collection(coll).doc(id).set(
-        stripUndefined({ userId, items: items ?? [], updatedAt: updatedAt ?? new Date() }),
+        stripUndefined(
+          stampSeedPurpose(
+            coll,
+            { userId, items: items ?? [], updatedAt: updatedAt ?? new Date() },
+            LOAD_STARTED_AT,
+          ),
+        ),
         { merge: false },
       );
       stats.created++;
@@ -643,17 +696,128 @@ async function loadGeneric(colName, seed, firestoreCollection, stats) {
     if (!data.slug) data.slug = docData.slug ?? docId;
     items.push({
       ref: db.collection(firestoreCollection).doc(docId),
-      data: encryptSeedPii(colName, stripUndefined(data)),
+      /*
+       * 🛑 Stamp provenance BEFORE `stripUndefined`, not after.
+       *
+       * `seedPurposeFields` deliberately OMITS `isTestData` for a `permanent`
+       * row rather than writing `false` — so stamping afterwards would be
+       * indistinguishable from not stamping, and stripping afterwards is what
+       * keeps the absence genuine instead of writing `undefined` keys.
+       *
+       * One call, one choke point: every one of the ~2,500 documents this
+       * loader writes gets a `seedPurpose`, so the purge is a query rather than
+       * a heuristic, and `users`/`orders` are reachable by it for the first
+       * time.
+       */
+      data: encryptSeedPii(colName, stripUndefined(stampSeedPurpose(colName, data, LOAD_STARTED_AT))),
     });
   }
-  const BATCH = 500;
-  for (let i = 0; i < items.length; i += BATCH) {
-    const chunk = items.slice(i, i + BATCH);
+  /*
+   * 🛑 Chunk by INDEX ENTRIES, not just by operation count.
+   *
+   * This loop capped at 500 operations and nothing else. That was invisible for
+   * years because every seeded collection had small documents; B5's 416
+   * categories are the first that do not. Measured 2026-10-11: one 416-op
+   * commit failed with `INVALID_ARGUMENT: Transaction too big` and wrote
+   * **0 of 416** — not a partial load, nothing at all.
+   *
+   * 🛑 The failure mode is what makes this worth a real fix rather than a
+   * retry: `✓ Load complete — created 2097, errors 1` reads as a near-complete
+   * run, and the ONE missing collection was the taxonomy that every product's
+   * `categorySlugs` chain points into. A purge-then-load left 70 products
+   * referencing ids that did not exist, with a cheerful summary line.
+   *
+   * ## What actually binds, measured by bisection rather than assumed
+   *
+   * My first fix capped PAYLOAD BYTES, on the theory that these documents are
+   * large. They are not: 416 categories are **1.51 MiB total**, mean 3.7 KiB,
+   * largest 7.9 KiB — nowhere near the 10 MiB request limit, and the byte cap
+   * never once triggered. The commit failed anyway.
+   *
+   * Bisecting the op count found the real boundary, and counting array elements
+   * explains it exactly:
+   *
+   *     416 ops -> 60,787 array elements -> FAILS
+   *     250 ops -> 42,912               -> FAILS
+   *     100 ops -> 17,578               -> works
+   *      50 ops ->  8,791               -> works
+   *
+   * The threshold sits right at **40,000**, which is Firestore's documented
+   * maximum index entries — applied per COMMIT here, not per document. Every
+   * element of an indexed array is an index entry, and a category carries ~146
+   * of them (`searchTxt` alone is ~150 tokens, plus `parentIds`, `ancestors`,
+   * `categoryNames`, `faqs`, `highlights`, `descriptionTemplates`).
+   *
+   * So the cap is on array elements at **20,000** — half the real limit, the
+   * same margin the byte cap keeps — and it is kept alongside the op and byte
+   * caps rather than replacing them, because all three are real Firestore
+   * limits and only one of them has bitten so far.
+   *
+   * 🛑 Do NOT "simplify" this back to a lower fixed op count. 100 would work
+   * for categories and silently triple the commit count for `faqs` and the
+   * 1,337 tester checklist items, which carry almost no arrays. The cap has to
+   * key on the thing that varies.
+   */
+  const MAX_OPS = Number(process.env.SEED_BATCH_OPS ?? 500);
+  const MAX_BYTES = 4 * 1024 * 1024;
+  const MAX_INDEX_ENTRIES = Number(process.env.SEED_BATCH_INDEX_ENTRIES ?? 20_000);
+
+  /** Array elements, recursively — a proxy for index entries written. */
+  const countArrayElements = (v) => {
+    if (Array.isArray(v)) return v.length + v.reduce((s, x) => s + countArrayElements(x), 0);
+    if (v && typeof v === "object" && !(v instanceof Date)) {
+      return Object.values(v).reduce((s, x) => s + countArrayElements(x), 0);
+    }
+    return 0;
+  };
+
+  let chunk = [];
+  let chunkBytes = 0;
+  let chunkEntries = 0;
+  const flush = async () => {
+    if (chunk.length === 0) return;
     const batch = db.batch();
     for (const { ref, data } of chunk) batch.set(ref, data, { merge: true });
     await batch.commit();
     stats.created += chunk.length;
+    chunk = [];
+    chunkBytes = 0;
+    chunkEntries = 0;
+  };
+
+  for (const item of items) {
+    let size = 0;
+    try {
+      size = Buffer.byteLength(JSON.stringify(item.data), "utf8");
+    } catch {
+      /*
+       * A payload that cannot be serialised cannot be measured. Treat it as a
+       * whole chunk's worth rather than as zero — guessing small is how a
+       * commit silently grows past a limit again, and a document that resists
+       * measurement is the one most likely to be large.
+       */
+      size = MAX_BYTES;
+    }
+    const entries = countArrayElements(item.data);
+    /*
+     * A single document over any cap still has to be written, and alone: a
+     * one-document commit is the smallest thing committable, so if Firestore
+     * rejects THAT the document itself is the problem and the error says so,
+     * rather than the failure being absorbed into a chunking bug.
+     */
+    if (
+      chunk.length > 0 &&
+      (chunk.length >= MAX_OPS ||
+        chunkBytes + size > MAX_BYTES ||
+        chunkEntries + entries > MAX_INDEX_ENTRIES)
+    ) {
+      await flush();
+    }
+    chunk.push(item);
+    chunkBytes += size;
+    chunkEntries += entries;
   }
+  await flush();
 }
 
 // ---------------------------------------------------------------------------

package/dist/_internal/server/jobs/handlers/testerSandboxCleanup.d.ts

@@ -1,2 +0,0 @@
-import type { ScheduleHandler } from "../runtime/types";
-export declare const testerSandboxCleanupHandler: ScheduleHandler;

package/dist/_internal/server/jobs/handlers/testerSandboxCleanup.js

@@ -1,2 +0,0 @@
-import { runTesterSandboxCleanup } from "../core/testerSandboxCleanup";
-export const testerSandboxCleanupHandler = (ctx) => runTesterSandboxCleanup(ctx);

package/dist/features/tester/actions/leaderboard-actions.d.ts

@@ -1,3 +0,0 @@
-import type { BugHunterLeaderboardEntry } from "../schemas/firestore";
-/** Ranks testers by confirmed-bug count. Mirrors getEventLeaderboard()'s shape. */
-export declare function getBugHunterLeaderboard(limit?: number): Promise<BugHunterLeaderboardEntry[]>;

package/dist/features/tester/actions/leaderboard-actions.js

@@ -1,5 +0,0 @@
-import { testerChecklistItemRepository } from "../repository/tester-checklist-item.repository";
-/** Ranks testers by confirmed-bug count. Mirrors getEventLeaderboard()'s shape. */
-export async function getBugHunterLeaderboard(limit = 50) {
-    return testerChecklistItemRepository.getBugHunterLeaderboard(limit);
-}

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

@@ -1,23 +0,0 @@
-import React from "react";
-import type { BugHunterLeaderboardEntry } from "../schemas/firestore";
-export interface BugHunterLeaderboardViewProps {
-    isLoading?: boolean;
-    isEmpty?: boolean;
-    /** Render the full ranked list — caller provides entries via hook */
-    renderList?: () => React.ReactNode;
-    /** Render a single row; used when caller wants item-level control */
-    renderEntry?: (entry: BugHunterLeaderboardEntry, index: number) => React.ReactNode;
-    /** Entries — used only when renderEntry is provided */
-    entries?: BugHunterLeaderboardEntry[];
-    /** Empty state node */
-    renderEmpty?: () => React.ReactNode;
-    /** Loading spinner / skeleton */
-    renderSkeleton?: () => React.ReactNode;
-    labels?: {
-        title?: string;
-        noEntries?: string;
-        bugs?: string;
-    };
-    className?: string;
-}
-export declare function BugHunterLeaderboardView({ isLoading, isEmpty, renderList, renderEntry, entries, renderEmpty, renderSkeleton, labels, className, }: BugHunterLeaderboardViewProps): React.JSX.Element;

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

@@ -1,18 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React from "react";
-import { Div, Row, Span, Stack, Text } from "../../../ui";
-export function BugHunterLeaderboardView({ isLoading = false, isEmpty = false, renderList, renderEntry, entries = [], renderEmpty, renderSkeleton, labels = {}, className = "", }) {
-    if (isLoading) {
-        if (renderSkeleton)
-            return _jsx(_Fragment, { children: renderSkeleton() });
-        return _jsx(Row, { justify: "center", padding: "y-xl", children: "Loading\u2026" });
-    }
-    if (isEmpty) {
-        if (renderEmpty)
-            return _jsx(_Fragment, { children: renderEmpty() });
-        return (_jsx(Text, { paddingY: "md", variant: "secondary", size: "sm", align: "start", children: labels.noEntries ?? "No confirmed bugs yet." }));
-    }
-    if (renderList)
-        return _jsx(Div, { className: className, children: renderList() });
-    return (_jsx(Stack, { className: `${className}`, gap: "sm", children: entries.map((entry, i) => renderEntry ? (_jsx(React.Fragment, { children: renderEntry(entry, i) }, entry.hunterId)) : (_jsxs(Div, { layout: "flex", align: "center", justify: "between", rounded: "xl", padding: "sm", className: "border", "data-section": "bughunterleaderboard-div", children: [_jsxs(Span, { weight: "medium", children: ["#", entry.rank, " ", entry.hunterName] }), _jsxs(Span, { children: [entry.bugCount, " ", labels.bugs ?? "bugs"] })] }, entry.hunterId))) }));
-}

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

@@ -1,5 +0,0 @@
-import React from "react";
-export interface TesterHubViewProps {
-    sandboxExpiresAt?: string | null;
-}
-export declare function TesterHubView({ sandboxExpiresAt }: TesterHubViewProps): React.JSX.Element;

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

@@ -1,110 +0,0 @@
-"use client";
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import React from "react";
-import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { Alert, Details, Div, FieldInput, Heading, Stack, Summary, Text, TextLink } from "../../../ui";
-import { apiClient } from "../../../http";
-import { useApiMutation } from "../../../client";
-import { useSession } from "../../../react";
-import { ACCOUNT_ENDPOINTS } from "../../../constants/api-endpoints";
-import { ROUTES } from "../../../next/routing/route-map";
-import { TesterChecklistStepRow } from "./TesterChecklistStepRow";
-function matchesQuery(item, query) {
-    if (!query)
-        return true;
-    const haystack = `${item.label} ${item.description ?? ""} ${item.groupLabel} ${item.pageLabel} ${item.href ?? ""}`.toLowerCase();
-    return haystack.includes(query.toLowerCase());
-}
-function TesterChecklistPageSection({ page, testerDisplayName, onAnswer, onSaveNote }) {
-    const answeredCount = page.items.filter((i) => i.answer).length;
-    return (_jsxs(Details, { tone: "card", defaultOpen: false, children: [_jsxs(Summary, { children: [page.pageLabel, " (", answeredCount, "/", page.items.length, " answered)"] }), _jsx(Div, { padding: "t-sm", children: _jsx(Stack, { gap: "sm", children: page.items
-                        .slice()
-                        .sort((a, b) => a.order - b.order)
-                        .map((item) => (_jsx(TesterChecklistStepRow, { testerDisplayName: testerDisplayName, item: {
-                            checklistItemId: item.id,
-                            label: item.label,
-                            description: item.description,
-                            href: item.href,
-                            roles: item.roles,
-                            startPage: item.startPage,
-                            steps: item.steps,
-                            inputs: item.inputs,
-                            expectedBehaviour: item.expectedBehaviour,
-                            expectedUiState: item.expectedUiState,
-                            expectedData: item.expectedData,
-                            endResult: item.endResult,
-                            answer: item.answer,
-                            comment: item.comment,
-                            screenshotUrl: item.screenshotUrl,
-                        }, onAnswer: onAnswer, onSaveNote: onSaveNote }, item.id))) }) })] }));
-}
-export function TesterHubView({ sandboxExpiresAt }) {
-    const { user } = useSession();
-    const queryClient = useQueryClient();
-    const [search, setSearch] = React.useState("");
-    const query = useQuery({
-        queryKey: ["user", "tester-checklist"],
-        queryFn: async () => {
-            const res = await apiClient.get(ACCOUNT_ENDPOINTS.TESTER_CHECKLIST);
-            return res?.data ?? res;
-        },
-        // The API route resolves isTester/canTestAdmin fresh from Firestore on
-        // every request, so retrying a 403 (a role that genuinely lacks access)
-        // wastes calls for no benefit — but a real access grant should still be
-        // visible on the very next request, not cached as a permanent failure.
-        retry: false,
-    });
-    const upsertMutation = useApiMutation({
-        mutationFn: async (vars) => apiClient.put(ACCOUNT_ENDPOINTS.TESTER_CHECKLIST_ITEM_BY_ID(vars.checklistItemId), vars.patch),
-        onSuccess: () => {
-            void queryClient.invalidateQueries({ queryKey: ["user", "tester-checklist"] });
-        },
-    });
-    // Gate on the live API response, not the client-cached session snapshot.
-    // SessionContext only refreshes role/isTester/canTestAdmin periodically
-    // (every 5 minutes) or on a hard reload/re-login — never on ordinary
-    // client-side navigation — so a flag an admin just granted would
-    // otherwise still read as "Testers only" here for up to 5 minutes even
-    // though the same request already succeeds server-side. The tester-
-    // checklist API resolves these fields fresh from Firestore on every call,
-    // so trusting its actual response is both more accurate and immediate.
-    const isForbidden = query.isError && query.error?.status === 403;
-    if (isForbidden) {
-        return (_jsx(Alert, { variant: "warning", title: "Testers only", children: "This page is only available to accounts flagged as testers (and admins). Contact an admin if you believe this is a mistake." }));
-    }
-    if (query.isLoading) {
-        return _jsx(Text, { color: "muted", children: "Loading checklist\u2026" });
-    }
-    // Items arrive pre-sorted by catalog `order` (listActive() orders by it).
-    const items = query.data?.items ?? [];
-    const filtered = items.filter((item) => matchesQuery(item, search));
-    const phases = new Map();
-    for (const item of filtered) {
-        if (!phases.has(item.phase))
-            phases.set(item.phase, new Map());
-        const groups = phases.get(item.phase);
-        if (!groups.has(item.groupKey))
-            groups.set(item.groupKey, { groupLabel: item.groupLabel, pages: new Map() });
-        const group = groups.get(item.groupKey);
-        if (!group.pages.has(item.pageKey))
-            group.pages.set(item.pageKey, { pageLabel: item.pageLabel, items: [] });
-        group.pages.get(item.pageKey).items.push(item);
-    }
-    const sortedPhaseNumbers = Array.from(phases.keys()).sort((a, b) => a - b);
-    const handleAnswer = (checklistItemId, answer) => {
-        upsertMutation.mutate({ checklistItemId, patch: { answer } });
-    };
-    const handleSaveNote = async (checklistItemId, comment, screenshotUrl) => {
-        await upsertMutation.mutateAsync({ checklistItemId, patch: { comment, screenshotUrl } });
-    };
-    return (_jsxs(Stack, { gap: "lg", children: [_jsx(Heading, { level: 1, children: "Tester Hub" }), _jsx(Text, { color: "muted", children: "Work through the checklist below and answer Yes/No for each test case. Add a comment and screenshot wherever something looks off \u2014 colors, styles, readability, bugs. Your answers save automatically." }), _jsx(TextLink, { href: String(ROUTES.PUBLIC.BUG_HUNTERS), variant: "underline", weight: "medium", children: "View Bug Hunters Leaderboard \u2192" }), sandboxExpiresAt && (_jsxs(Alert, { variant: "info", title: "Shared test sandbox", children: ["The shared test store/products/categories expire on ", new Date(sandboxExpiresAt).toLocaleDateString(), "."] })), _jsx(FieldInput, { name: "checklist-search", label: "Search test cases", value: search, onChange: setSearch, placeholder: "Search by title or route, e.g. checkout, /store/payouts..." }), sortedPhaseNumbers.map((phaseNumber) => {
-                const groups = phases.get(phaseNumber);
-                const phaseItemCount = Array.from(groups.values())
-                    .flatMap((g) => Array.from(g.pages.values()))
-                    .reduce((sum, page) => sum + page.items.length, 0);
-                const phaseAnswered = Array.from(groups.values())
-                    .flatMap((g) => Array.from(g.pages.values()))
-                    .reduce((sum, page) => sum + page.items.filter((i) => i.answer).length, 0);
-                return (_jsxs(Details, { tone: "card", defaultOpen: false, children: [_jsxs(Summary, { size: "lg", weight: "bold", children: ["Phase ", phaseNumber, " (", phaseAnswered, "/", phaseItemCount, " answered)"] }), _jsx(Div, { padding: "t-sm", children: _jsx(Stack, { gap: "md", children: Array.from(groups.entries()).map(([groupKey, group]) => (_jsxs(Stack, { gap: "sm", children: [_jsx(Heading, { level: 4, children: group.groupLabel }), Array.from(group.pages.entries()).map(([pageKey, page]) => (_jsx(TesterChecklistPageSection, { page: page, testerDisplayName: user?.displayName ?? user?.email ?? "tester", onAnswer: handleAnswer, onSaveNote: handleSaveNote }, pageKey)))] }, groupKey))) }) })] }, phaseNumber));
-            })] }));
-}

package/dist/features/tester/seed-data/authored/public-pages__bug-hunters.d.ts

@@ -1,2 +0,0 @@
-import type { AuthoredCase } from "./_types";
-export declare const authored: Record<string, AuthoredCase>;

package/dist/features/tester/seed-data/authored/public-pages__bug-hunters.js

@@ -1,78 +0,0 @@
-/*
- * WHY: Authored six-part procedures for the public-pages/bug-hunters page.
- * WHAT: 3 case(s), keyed by full checklist id.
- *
- * Written by hand, case by case, against the label each one states. There is no
- * generator: the authoring scripts were deleted once it was clear they were
- * scaffolding around work that is simply writing.
- *
- * The leaderboard exists to credit PEOPLE, which is why the bot account carries
- * isBot and must not appear on it — a runner that works all 994 cases would top
- * the board permanently and make it worthless as recognition.
- *
- * @tag domain:tester
- * @tag layer:seed
- * @tag pattern:none
- * @tag access:server-only
- * @tag consumers:seed-data/authored/index.ts
- * @tag sideEffects:none
- */
-export const authored = {
-    "checklist-public-pages-bug-hunters-leaderboard-loads": {
-        roles: ["guest"],
-        startPage: "/bug-hunters",
-        steps: [
-            "Open /bug-hunters in a private window with no session.",
-            "Read the rows from the top and note each name and confirmed-bug count.",
-            "Check that the counts descend from the first row to the last.",
-            /*
-             * 'Mock User 3' — the demo fixture's bugHunterName, matching
-             * bugHunterId "user-yugi-muto". This said 'Mock User 18', and there is no
-             * such persona: the seed runs Mock User 1–17 plus two Mock Employees.
-             *
-             * So the tester looked for a name that cannot be on the board, found
-             * nothing, and the case failed for a reason that is not a bug — while
-             * the leaderboard's real behaviour went unchecked.
-             */
-            "Look for 'Mock User 3' and read the count beside it.",
-            "Look for the Claude tester account by name anywhere in the list.",
-        ],
-        inputs: { seededHunter: "Mock User 3", seededBugCount: 1 },
-        expectedBehaviour: "The board ranks testers by confirmed-bug count, highest first, and is fed by the demo fixture under Admin (Testing) → Bug Hunter Rewards. The bot account is excluded because it carries isBot — credit belongs to people, and a runner working the whole checklist would otherwise sit at the top forever.",
-        expectedUiState: "'Mock User 3' appears with 1 confirmed bug. Counts never increase as you read down the list. The Claude tester account does not appear at all.",
-        expectedData: { botAccountOnLeaderboard: 0 },
-        endResult: "Read-only; nothing persists. A bot row on the board is a fail even if the ordering is otherwise correct.",
-    },
-    "checklist-public-pages-bug-hunters-leaderboard-empty-state": {
-        roles: ["admin", "guest"],
-        startPage: "/bug-hunters",
-        steps: [
-            "Sign in as admin@letitrip.in / TempPass123!.",
-            "Open /admin/tester-feedback and find the confirmed bug credited to 'Mock User 3'.",
-            "Un-confirm it, so no confirmed bugs remain.",
-            "Open /bug-hunters in a private window with no session.",
-            "Read the page.",
-            "Return to /admin/tester-feedback and confirm the bug again.",
-            "Reload /bug-hunters in the private window.",
-        ],
-        expectedBehaviour: "With nothing to rank the page shows a named empty state rather than a blank container or an error. Zero rows is a normal condition for this page on a new install, not a failure.",
-        expectedUiState: "With no confirmed bugs the page reads 'No confirmed bugs yet' or equivalent, inside the normal site chrome. It is not a blank white page, not an error boundary, and not a heading with nothing under it. After re-confirming, 'Mock User 3' is back.",
-        expectedData: { emptyStateShown: true },
-        endResult: "The confirmation is restored by the final step, so the leaderboard-loads case above still has its fixture. Leaving it un-confirmed silently breaks that case.",
-    },
-    "checklist-public-pages-bug-hunters-leaderboard-footer-link": {
-        roles: ["guest"],
-        startPage: "/",
-        steps: [
-            "Open / in a private window with no session.",
-            "Scroll to the footer and find the Support column.",
-            "Read the links in that column.",
-            "Click 'Bug Hunters'.",
-            "Read the address bar and the page.",
-        ],
-        expectedBehaviour: "The leaderboard is reachable from the footer. A page with no nav entry is exactly as unfinished as a nav entry with no page — this is the first half of that pair.",
-        expectedUiState: "A 'Bug Hunters' link is present in the footer's Support column and clicking it lands on /bug-hunters with the leaderboard rendered. Not a 404 and not a redirect to /.",
-        expectedData: { footerLinkHref: "/bug-hunters" },
-        endResult: "Read-only; nothing persists.",
-    },
-};

package/dist/features/tester/seed-data/tester-ttl.d.ts

@@ -1,4 +0,0 @@
-/** Shared 7-day TTL stamp for tester sandbox seed fixtures — recomputed fresh every seed run,
- *  so re-seeding naturally refreshes the expiry (matches TESTER_SANDBOX_TTL_DAYS). */
-export declare const TESTER_SANDBOX_TTL_DAYS = 7;
-export declare function testDataExpiresAt(): Date;

package/dist/features/tester/seed-data/tester-ttl.js

@@ -1,6 +0,0 @@
-/** Shared 7-day TTL stamp for tester sandbox seed fixtures — recomputed fresh every seed run,
- *  so re-seeding naturally refreshes the expiry (matches TESTER_SANDBOX_TTL_DAYS). */
-export const TESTER_SANDBOX_TTL_DAYS = 7;
-export function testDataExpiresAt() {
-    return new Date(Date.now() + TESTER_SANDBOX_TTL_DAYS * 24 * 60 * 60 * 1000);
-}