@mohasinac/appkit 4.57.0 → 4.58.0

package/dist/.build-stamp.json

@@ -1,8 +1,8 @@
 {
   "stampVersion": 1,
-  "version": "4.57.0",
-  "head": "de32aea7a1bbb5fe9970959866c5278c2f9e4e49",
+  "version": "4.58.0",
+  "head": "978d9ef892ec5d3ef08a87c7f040877faf3c5daa",
   "branch": "main",
-  "dirty": true,
-  "builtAt": "2026-10-20T18:02:32.256Z"
+  "dirty": false,
+  "builtAt": "2026-10-20T20:29:00.050Z"
 }

package/dist/_internal/server/features/beys/data.d.ts

@@ -0,0 +1,44 @@
+import { type BeyDocument, type BeyProductDocument } from "../../../../features/beys/schemas/firestore";
+/**
+ * One bey, by slug.
+ *
+ * 🛑 A DIRECT DOC READ — `id === slug`, so this needs no query, no index and
+ * no scan. That is the whole reason the id is the slug.
+ */
+export declare const getBeyBySlug: (slug: string) => Promise<BeyDocument | null>;
+/**
+ * The bey(s) paired with a category leaf — the inverse of `BeyDocument.categoryId`.
+ *
+ * 🛑 ONE INDEXED EQUALITY, no composite index, which is the same shape
+ * `getCompositionsForCategory` uses for the parts side of this exact job. A
+ * single-field `==` is served by Firestore's automatic index, so this adds no
+ * index to declare and no deploy to wait on.
+ *
+ * 🛑 NOT `.limit(1)`, and that is measured rather than cautious. 1,880 beys
+ * carry a `categoryId` across 1,858 distinct leaves — so **22 leaves pair with
+ * TWO beys**, which are the vendor pairs (a Takara-Tomy release and its Hasbro
+ * equivalent merged onto one taxonomy leaf). `limit(1)` would render one of
+ * them and silently drop the other on 22 pages, with nothing to indicate a
+ * second existed. The cap is small and the extra rows are the point.
+ *
+ * Fails OPEN to an empty list for the same reason as below: a category page
+ * missing its reference link is a worse page, a category page that throws is no
+ * page at all.
+ */
+export declare const getBeysForCategory: (categoryId: string) => Promise<BeyDocument[]>;
+/**
+ * The products that ship a bey.
+ *
+ * 🛑 A QUERY, unlike `getModelsUsingPart`'s `getAll`, and the difference is a
+ * real asymmetry in the data rather than an inconsistency: a part row carries
+ * `usedBy` so its models are ids already in hand, whereas the product→bey edge
+ * lives on the PRODUCT (`assortment[].beyId`). A bey has no stored list of the
+ * products containing it.
+ *
+ * So this is one `array-contains` over a denormalised id array, bounded at 12.
+ * 🛑 It needs `assortmentBeyIds` on the product — a flat array of the ids
+ * inside `assortment[]`, because Firestore cannot `array-contains` on a field
+ * nested inside objects in an array. Until the seed carries that field this
+ * returns [] and says so, rather than running a scan.
+ */
+export declare const getProductsContainingBey: (beyId: string) => Promise<BeyProductDocument[]>;

package/dist/_internal/server/features/beys/data.js

@@ -0,0 +1,107 @@
+/**
+ * Reads for the public bey surfaces.
+ *
+ * 🛑 Wrapped in `React.cache` because a page and its `generateMetadata` share
+ * the call — and the NARROWEST shared call is what gets cached, not whatever
+ * is convenient to export. `React.cache` memoises per argument list, so two
+ * call sites passing different arguments get two entries and dedupe nothing
+ * (the `getStoreBySlug(slug)` vs `getStoreBySlug(slug, viewer)` trap).
+ */
+import { cache } from "react";
+import { BEYS_COLLECTION, BEY_PRODUCTS_COLLECTION, } from "../../../../features/beys/schemas/firestore.js";
+import { getAdminDb } from "../../../../providers/db-firebase/index.js";
+import { BEY_FIELDS } from "../../../../constants/field-names.js";
+import { serverLogger } from "../../../../monitoring/server-logger.js";
+import { normalizeError } from "../../../../errors/normalize.js";
+/**
+ * One bey, by slug.
+ *
+ * 🛑 A DIRECT DOC READ — `id === slug`, so this needs no query, no index and
+ * no scan. That is the whole reason the id is the slug.
+ */
+export const getBeyBySlug = cache(async (slug) => {
+    try {
+        const snap = await getAdminDb().collection(BEYS_COLLECTION).doc(slug).get();
+        return snap.exists ? { id: snap.id, ...snap.data() } : null;
+    }
+    catch (err) {
+        const e = normalizeError(err);
+        serverLogger.warn("getBeyBySlug failed", { slug, error: e.message });
+        return null;
+    }
+});
+/**
+ * The bey(s) paired with a category leaf — the inverse of `BeyDocument.categoryId`.
+ *
+ * 🛑 ONE INDEXED EQUALITY, no composite index, which is the same shape
+ * `getCompositionsForCategory` uses for the parts side of this exact job. A
+ * single-field `==` is served by Firestore's automatic index, so this adds no
+ * index to declare and no deploy to wait on.
+ *
+ * 🛑 NOT `.limit(1)`, and that is measured rather than cautious. 1,880 beys
+ * carry a `categoryId` across 1,858 distinct leaves — so **22 leaves pair with
+ * TWO beys**, which are the vendor pairs (a Takara-Tomy release and its Hasbro
+ * equivalent merged onto one taxonomy leaf). `limit(1)` would render one of
+ * them and silently drop the other on 22 pages, with nothing to indicate a
+ * second existed. The cap is small and the extra rows are the point.
+ *
+ * Fails OPEN to an empty list for the same reason as below: a category page
+ * missing its reference link is a worse page, a category page that throws is no
+ * page at all.
+ */
+export const getBeysForCategory = cache(async (categoryId) => {
+    try {
+        const snap = await getAdminDb()
+            .collection(BEYS_COLLECTION)
+            .where(BEY_FIELDS.CATEGORY_ID, "==", categoryId)
+            .limit(4)
+            .get();
+        return snap.docs.map((d) => ({ id: d.id, ...d.data() }));
+    }
+    catch (err) {
+        const e = normalizeError(err);
+        serverLogger.warn("getBeysForCategory failed", { categoryId, error: e.message });
+        return [];
+    }
+});
+/**
+ * The products that ship a bey.
+ *
+ * 🛑 A QUERY, unlike `getModelsUsingPart`'s `getAll`, and the difference is a
+ * real asymmetry in the data rather than an inconsistency: a part row carries
+ * `usedBy` so its models are ids already in hand, whereas the product→bey edge
+ * lives on the PRODUCT (`assortment[].beyId`). A bey has no stored list of the
+ * products containing it.
+ *
+ * So this is one `array-contains` over a denormalised id array, bounded at 12.
+ * 🛑 It needs `assortmentBeyIds` on the product — a flat array of the ids
+ * inside `assortment[]`, because Firestore cannot `array-contains` on a field
+ * nested inside objects in an array. Until the seed carries that field this
+ * returns [] and says so, rather than running a scan.
+ */
+export const getProductsContainingBey = cache(async (beyId) => {
+    try {
+        const snap = await getAdminDb()
+            .collection(BEY_PRODUCTS_COLLECTION)
+            .where("assortmentBeyIds", "array-contains", beyId)
+            .limit(12)
+            .get();
+        return snap.docs.map((d) => ({ id: d.id, ...d.data() }));
+    }
+    catch (err) {
+        const e = normalizeError(err);
+        /*
+         * Fails OPEN to an empty list. A missing composite index throws
+         * `FAILED_PRECONDITION`, and the right outcome is a bey page without its
+         * "found in" section rather than a broken page — the caller wraps this in
+         * `safeRead` as well, so the degradation is recorded rather than silent.
+         *
+         * 🛑 `normalizeError` is the FIRST statement on purpose. It was below
+         * this comment, which put it outside audit-catch-normalize's proximity
+         * window — so the audit correctly reported it as missing even though the
+         * call was right there. Comment after the call, never before it.
+         */
+        serverLogger.warn("getProductsContainingBey failed", { beyId, error: e.message });
+        return [];
+    }
+});

package/dist/_internal/server/features/beys/og.d.ts

@@ -0,0 +1,42 @@
+/**
+ * OG card for `/beys/{slug}`.
+ *
+ * ── 🛑 NO IMAGE FETCHES, FOR THE REASON THE PARTS CARDS DO NOT EITHER ─────
+ *
+ * Beys DO have photographs — 1,903 of 1,988 — so this is a deliberate refusal
+ * rather than a gap. The project was suspended for **Fast Origin Transfer at
+ * 5.25× its allowance** (52.52 GB against 10 GB), traced to render-time image
+ * proxying (Root Cause #104). 1,988 bey routes with one remote fetch each, on
+ * a crawler sweep, is precisely the amplification that was just removed. Type
+ * on a gradient costs one lambda and nothing else.
+ *
+ * ── 🛑 NO MONEY ON THE CANVAS ─────────────────────────────────────────────
+ *
+ * All eight money-bearing OG renderers were stripped, and the rule is stated
+ * in CLAUDE.md: an OG image is a public image URL with the amount burned into
+ * the pixels, so no sign-in gate reaches it and no paywall markup describes
+ * it. 1,309 beys carry a price in the research data and none of it appears
+ * here.
+ *
+ * `audit-guest-price-leak`'s R1 blocks a `₹` in any `og.tsx`, so this is
+ * mechanically enforced rather than left to discipline.
+ */
+import type { ReactElement } from "react";
+import type { BeyDocument } from "../../../../features/beys/schemas/firestore";
+/**
+ * One bey's card.
+ *
+ * 🛑 EVERY CLAUSE IS CONDITIONAL, because the coverage genuinely varies: 93%
+ * of beys have a mass but only 248 state it directly, and `system` is on 94%
+ * while `type` and `spinDirection` are lower. A card reading "0 g" or an empty
+ * separator would be a claim the data does not support — the same reason the
+ * parts card builds its detail line by filtering.
+ *
+ * 🛑 The mass is marked `≈` when it was SUMMED from the parts rather than
+ * stated, which is the same honesty the detail page applies. A derived figure
+ * printed as an exact one is the single easiest way for this dataset to start
+ * lying.
+ */
+export declare function renderBeyOg(bey: BeyDocument | null | undefined, opts: {
+    siteName: string;
+}): ReactElement;

package/dist/_internal/server/features/beys/og.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const BG = "#0f172a";
+const GRADIENT = "linear-gradient(135deg, #0f172a 0%, #1e293b 100%)";
+const MUTED = "#94a3b8";
+const ACCENT = "#5eead4";
+/*
+ * 🛑 A COPY of the parts shell, not an import, and that is a considered
+ * choice rather than laziness.
+ *
+ * The Duplication Decision Framework's Rule of Three says extract on the
+ * THIRD copy, not the second — "two copies is observation; three is a
+ * pattern". There are now exactly two OG shells of this shape. Lifting it to
+ * a shared module today would also put a third consumer between every OG
+ * renderer and its layout for no behavioural gain.
+ *
+ * When a third appears, extract then. The constants above are duplicated for
+ * the same reason and in the same breath.
+ */
+function shell(eyebrow, title, detail, siteName) {
+    return (_jsxs("div", { style: {
+            display: "flex",
+            width: "100%",
+            height: "100%",
+            background: BG,
+            fontFamily: "sans-serif",
+            position: "relative",
+            overflow: "hidden",
+            alignItems: "center",
+            justifyContent: "center",
+        }, children: [_jsx("div", { style: { position: "absolute", inset: 0, background: GRADIENT } }), _jsxs("div", { style: {
+                    position: "relative",
+                    display: "flex",
+                    flexDirection: "column",
+                    alignItems: "center",
+                    gap: 24,
+                    padding: "60px",
+                    textAlign: "center",
+                }, children: [_jsx("div", { style: {
+                            fontSize: 20,
+                            color: ACCENT,
+                            fontWeight: 600,
+                            letterSpacing: 3,
+                            textTransform: "uppercase",
+                        }, children: eyebrow }), _jsx("div", { style: {
+                            fontSize: title.length > 34 ? 56 : 76,
+                            color: "#ffffff",
+                            fontWeight: 700,
+                            lineHeight: 1.1,
+                        }, children: title }), detail && _jsx("div", { style: { fontSize: 28, color: MUTED }, children: detail }), _jsx("div", { style: { fontSize: 20, color: MUTED, marginTop: 8 }, children: siteName })] })] }));
+}
+/**
+ * One bey's card.
+ *
+ * 🛑 EVERY CLAUSE IS CONDITIONAL, because the coverage genuinely varies: 93%
+ * of beys have a mass but only 248 state it directly, and `system` is on 94%
+ * while `type` and `spinDirection` are lower. A card reading "0 g" or an empty
+ * separator would be a claim the data does not support — the same reason the
+ * parts card builds its detail line by filtering.
+ *
+ * 🛑 The mass is marked `≈` when it was SUMMED from the parts rather than
+ * stated, which is the same honesty the detail page applies. A derived figure
+ * printed as an exact one is the single easiest way for this dataset to start
+ * lying.
+ */
+export function renderBeyOg(bey, opts) {
+    if (!bey)
+        return shell("Beyblades", "Beyblade database", "", opts.siteName);
+    const statedMass = typeof bey.weightG === "number" ? bey.weightG : null;
+    const summedMass = typeof bey.weightGFromParts === "number" ? bey.weightGFromParts : null;
+    const mass = statedMass !== null
+        ? `${statedMass} g`
+        : summedMass !== null
+            ? `≈ ${Math.round(summedMass * 10) / 10} g`
+            : null;
+    const bits = [
+        bey.type ? `${bey.type} type` : null,
+        bey.spinDirection ?? null,
+        mass,
+        bey.composition?.length ? `${bey.composition.length} parts` : null,
+    ].filter((b) => b !== null);
+    /*
+     * The eyebrow is the SYSTEM (Hybrid Wheel System, Burst Ultimate…) because
+     * that is the one line a collector uses to place a bey in time, and it is
+     * present on 94% of them. `series` is the fallback and "Beyblade" the floor
+     * — never an empty eyebrow, which reads as a broken template.
+     */
+    const eyebrow = bey.system ?? bey.series ?? "Beyblade";
+    return shell(eyebrow, bey.name, bits.join("  ·  "), opts.siteName);
+}

package/dist/_internal/server/features/parts/data.js

@@ -11,6 +11,7 @@ import { PART_GLOSSARY_COLLECTION, MODEL_COMPOSITION_COLLECTION, partGlossaryId,
 import { getAdminDb } from "../../../../providers/db-firebase/index.js";
 import { serverLogger } from "../../../../monitoring/server-logger.js";
 import { normalizeError } from "../../../../errors/normalize.js";
+import { MODEL_COMPOSITION_FIELDS, PART_GLOSSARY_FIELDS, } from "../../../../constants/field-names.js";
 /** The bucket cap. 87 is the largest real classification, so this clears it. */
 export const PART_SLOT_PAGE_SIZE = 120;
 /** One part, by `(slot, code|name)` — the only key this collection has. */
@@ -125,7 +126,7 @@ export const getCompositionsForCategory = cache(async (categoryId) => {
     try {
         const snap = await getAdminDb()
             .collection(MODEL_COMPOSITION_COLLECTION)
-            .where("categoryId", "==", categoryId)
+            .where(MODEL_COMPOSITION_FIELDS.CATEGORY_ID, "==", categoryId)
             .limit(8)
             .get();
         return snap.docs.map((d) => ({ id: d.id, ...d.data() }));
@@ -154,7 +155,7 @@ export const listPartsBySlot = cache(async (slot) => {
     try {
         const snap = await getAdminDb()
             .collection(PART_GLOSSARY_COLLECTION)
-            .where("slot", "==", slot)
+            .where(PART_GLOSSARY_FIELDS.SLOT, "==", slot)
             .limit(PART_SLOT_PAGE_SIZE)
             .get();
         const parts = snap.docs

package/dist/_internal/shared/actions/action-registry.d.ts

@@ -29,7 +29,7 @@ import type { IconKey } from "../../../ui/icons/icon-registry";
 /** What KIND of action — drives default UI affordance (link vs button vs danger). */
 export type ActionKind = "primary" | "secondary" | "danger" | "ghost" | "link" | "chip";
 /** Resource bucket — keyed top-level in the ACTIONS tree. */
-export type ActionResource = "PRODUCT" | "AUCTION" | "PRE_ORDER" | "PRIZE_DRAW" | "DIGITAL_CODE" | "BUNDLE" | "GROUP" | "CATEGORY" | "BRAND" | "SUBLISTING" | "STORE" | "BLOG" | "EVENT" | "REVIEW" | "SHIPMENT" | "CATALOGUE" | "USER" | "SELLER" | "ADMIN" | "CART" | "CHECKOUT" | "NAV" | "MEDIA" | "SUPPORT" | "LOTTERY" | "TESTER";
+export type ActionResource = "PRODUCT" | "AUCTION" | "PRE_ORDER" | "PRIZE_DRAW" | "DIGITAL_CODE" | "BUNDLE" | "GROUP" | "CATEGORY" | "BRAND" | "PART" | "BEY" | "SUBLISTING" | "STORE" | "BLOG" | "EVENT" | "REVIEW" | "SHIPMENT" | "CATALOGUE" | "USER" | "SELLER" | "ADMIN" | "CART" | "CHECKOUT" | "NAV" | "MEDIA" | "SUPPORT" | "LOTTERY" | "TESTER";
 /** Confirmation modal config — when set, <Button action={...}> opens
  *  a confirm dialog before firing the actual handler. */
 export interface ActionConfirmation {

package/dist/_internal/shared/actions/action-registry.js

@@ -432,6 +432,92 @@ export const ACTIONS = {
             },
         },
     },
+    /*
+     * ── 🛑 THE TWO GENERATED REFERENCE DATABASES ─────────────────────────────
+     *
+     * `partGlossary` (2,488) and `beys` (1,988) are built by committed
+     * generators from a crawled corpus. That shapes every leaf below:
+     *
+     *   · NO `create`. A row authored by hand has no source, vanishes on the
+     *     next regeneration, and makes "this dataset rebuilds from the repo"
+     *     false. Adding a part is a change to the generator, not a button.
+     *   · `edit` is CORRECT-A-WRONG-EXTRACTION, and says so, because that is
+     *     what it is for — the corpus was measurably wrong five times in one
+     *     session on mode data alone.
+     *   · `delete`'s confirmation does NOT say "cannot be undone", because that
+     *     would be a lie: the row is in a committed seed file and the next
+     *     reseed restores it. It says what actually happens.
+     */
+    PART: {
+        view: {
+            iconKey: "view",
+            id: "part.view",
+            label: "View",
+            ariaLabel: "View part",
+            description: "Open the part reference page.",
+            kind: "secondary",
+        },
+        edit: {
+            iconKey: "edit",
+            id: "part.edit",
+            label: "Edit",
+            ariaLabel: "Edit part",
+            description: "Correct this part's recorded details. The correction is kept when the database is regenerated.",
+            kind: "secondary",
+            permissions: ["admin"],
+        },
+        delete: {
+            iconKey: "delete",
+            id: "part.delete",
+            label: "Delete",
+            ariaLabel: "Delete part",
+            description: "Remove this part from the live database.",
+            kind: "danger",
+            permissions: ["admin"],
+            confirmation: {
+                title: "Remove this part from the live database?",
+                body: "Beyblades built from it keep their parts list and will show its name without a link. " +
+                    "This part is also in the committed seed data, so regenerating the database will bring it " +
+                    "back — to remove it for good, take it out of the generator.",
+                confirmLabel: "Remove",
+            },
+        },
+    },
+    BEY: {
+        view: {
+            iconKey: "view",
+            id: "bey.view",
+            label: "View",
+            ariaLabel: "View Beyblade",
+            description: "Open the Beyblade reference page.",
+            kind: "secondary",
+        },
+        edit: {
+            iconKey: "edit",
+            id: "bey.edit",
+            label: "Edit",
+            ariaLabel: "Edit Beyblade",
+            description: "Correct this Beyblade's recorded details. The correction is kept when the database is regenerated.",
+            kind: "secondary",
+            permissions: ["admin"],
+        },
+        delete: {
+            iconKey: "delete",
+            id: "bey.delete",
+            label: "Delete",
+            ariaLabel: "Delete Beyblade",
+            description: "Remove this Beyblade from the live database.",
+            kind: "danger",
+            permissions: ["admin"],
+            confirmation: {
+                title: "Remove this Beyblade from the live database?",
+                body: "Its category page and any listings under it are not touched, and boxed sets that include " +
+                    "it keep their contents list. It is also in the committed seed data, so regenerating the " +
+                    "database will bring it back — to remove it for good, take it out of the generator.",
+                confirmLabel: "Remove",
+            },
+        },
+    },
     CATEGORY: {
         view: {
             iconKey: "view",

package/dist/client.d.ts

@@ -437,6 +437,8 @@ export type { ListingTypeCapability } from "./_internal/shared/listing-types/cap
 export { LISTING_TYPE_REGISTRY, pluginFor, detectListingTypeFromSlug } from "./_internal/shared/listing-types/_registry";
 export { useStoreListingEntitlements } from "./features/seller/hooks/useStoreListingEntitlements";
 export { OwnerQuickActions } from "./features/admin/components/OwnerQuickActions";
+export { RecordOwnerQuickActions } from "./features/admin/components/RecordOwnerQuickActions";
+export type { RecordOwnerQuickActionsProps, RecordQuickActionResource } from "./features/admin/components/RecordOwnerQuickActions";
 export { YourPurchaseStrip } from "./features/orders/components/YourPurchaseStrip";
 export { ReviewFormDrawer, reviewFormSchema } from "./features/reviews/components/ReviewFormDrawer";
 export type { ReviewFormDrawerProps, ReviewFormValues } from "./features/reviews/components/ReviewFormDrawer";

package/dist/client.js

@@ -460,6 +460,7 @@ export { LISTING_TYPE_REGISTRY, pluginFor, detectListingTypeFromSlug } from "./_
 export { useStoreListingEntitlements } from "./features/seller/hooks/useStoreListingEntitlements.js";
 // Pencil / clone / bin for whoever owns the record, on a PUBLIC surface.
 export { OwnerQuickActions } from "./features/admin/components/OwnerQuickActions.js";
+export { RecordOwnerQuickActions } from "./features/admin/components/RecordOwnerQuickActions.js";
 // "You ordered this - track it" / "your review - edit it", on a product page.
 export { YourPurchaseStrip } from "./features/orders/components/YourPurchaseStrip.js";
 // The first review form this app has had - see the component's header.

package/dist/constants/api-endpoints.d.ts

@@ -126,6 +126,10 @@ export declare const ADMIN_ENDPOINTS: {
     readonly BUNDLE_REBUILD: (id: string) => string;
     readonly CATEGORIES: "/api/admin/categories";
     readonly CATEGORY_BY_ID: (id: string) => string;
+    readonly PARTS: "/api/admin/parts";
+    readonly PART_BY_ID: (id: string) => string;
+    readonly BEYS: "/api/admin/beys";
+    readonly BEY_BY_ID: (id: string) => string;
     readonly BRANDS: "/api/admin/brands";
     readonly BRAND_BY_ID: (id: string) => string;
     readonly FAQS: "/api/admin/faqs";
@@ -690,6 +694,10 @@ export declare const API_ENDPOINTS: {
         readonly BUNDLE_REBUILD: (id: string) => string;
         readonly CATEGORIES: "/api/admin/categories";
         readonly CATEGORY_BY_ID: (id: string) => string;
+        readonly PARTS: "/api/admin/parts";
+        readonly PART_BY_ID: (id: string) => string;
+        readonly BEYS: "/api/admin/beys";
+        readonly BEY_BY_ID: (id: string) => string;
         readonly BRANDS: "/api/admin/brands";
         readonly BRAND_BY_ID: (id: string) => string;
         readonly FAQS: "/api/admin/faqs";
@@ -1219,6 +1227,10 @@ export declare const API_ROUTES: {
         readonly BUNDLE_REBUILD: (id: string) => string;
         readonly CATEGORIES: "/api/admin/categories";
         readonly CATEGORY_BY_ID: (id: string) => string;
+        readonly PARTS: "/api/admin/parts";
+        readonly PART_BY_ID: (id: string) => string;
+        readonly BEYS: "/api/admin/beys";
+        readonly BEY_BY_ID: (id: string) => string;
         readonly BRANDS: "/api/admin/brands";
         readonly BRAND_BY_ID: (id: string) => string;
         readonly FAQS: "/api/admin/faqs";

package/dist/constants/api-endpoints.js

@@ -157,6 +157,16 @@ export const ADMIN_ENDPOINTS = {
     BUNDLE_REBUILD: (id) => `/api/admin/bundles/${id}/rebuild`,
     CATEGORIES: "/api/admin/categories",
     CATEGORY_BY_ID: (id) => `/api/admin/categories/${id}`,
+    /*
+     * The generated reference databases. PATCH corrects a wrong extraction;
+     * DELETE removes a row that should not exist. No POST — see the note on
+     * `ROUTES.ADMIN.PARTS` for why creating one by hand is not a supported
+     * operation on generated data.
+     */
+    PARTS: "/api/admin/parts",
+    PART_BY_ID: (id) => `/api/admin/parts/${id}`,
+    BEYS: "/api/admin/beys",
+    BEY_BY_ID: (id) => `/api/admin/beys/${id}`,
     BRANDS: "/api/admin/brands",
     BRAND_BY_ID: (id) => `/api/admin/brands/${id}`,
     FAQS: "/api/admin/faqs",

package/dist/constants/field-names.d.ts

@@ -509,6 +509,52 @@ export declare const STORE_FIELDS: {
         readonly TOTAL_PRODUCTS: "stats.totalProducts";
     };
 };
+/**
+ * The two GENERATED reference databases.
+ *
+ * 🛑 NOT reused from `CATEGORY_FIELDS`. `audit-route-nav-field-constants`
+ * suggested `CATEGORY_FIELDS.NAME` for a query against `partGlossary`, and the
+ * string would have been identical — which is exactly why that would be the
+ * wrong fix. A constant's job is to say WHICH collection's field is meant, so
+ * that renaming one collection's field cannot silently retarget another's
+ * query. Same bytes, different claim.
+ */
+/**
+ * `modelComposition` — which parts a model is built from.
+ *
+ * 🛑 ITS OWN `CATEGORY_ID`, not `BEY_FIELDS.CATEGORY_ID`. The audit suggested
+ * the bey constant for a query against THIS collection, and the string is
+ * identical — which is precisely the substitution the comment on
+ * `PART_GLOSSARY_FIELDS` warns about. A composition row's `categoryId` points
+ * at the model leaf it describes; a bey's points at its own paired leaf. Same
+ * bytes, two different facts, and only one of them moves if either is renamed.
+ */
+export declare const MODEL_COMPOSITION_FIELDS: {
+    readonly ID: "id";
+    readonly CATEGORY_ID: "categoryId";
+    readonly SLOT: "slot";
+};
+export declare const PART_GLOSSARY_FIELDS: {
+    readonly ID: "id";
+    readonly NAME: "name";
+    readonly SLOT: "slot";
+    readonly CLASSIFICATION: "classification";
+    readonly CODE: "code";
+    readonly WEIGHT_G: "weightG";
+    /** Set by `applyAdminEdit`; the seed loader queries on it. */
+    readonly ADMIN_EDITED: "adminEdited";
+    readonly ADMIN_EDITED_FIELDS: "adminEditedFields";
+};
+export declare const BEY_FIELDS: {
+    readonly ID: "id";
+    readonly SLUG: "slug";
+    readonly NAME: "name";
+    readonly TYPE: "type";
+    readonly SYSTEM: "system";
+    readonly CATEGORY_ID: "categoryId";
+    readonly ADMIN_EDITED: "adminEdited";
+    readonly ADMIN_EDITED_FIELDS: "adminEditedFields";
+};
 export declare const CATEGORY_FIELDS: {
     readonly ID: "id";
     readonly NAME: "name";

package/dist/constants/field-names.js

@@ -613,6 +613,52 @@ export const STORE_FIELDS = {
 // ============================================================================
 // CATEGORY FIELDS
 // ============================================================================
+/**
+ * The two GENERATED reference databases.
+ *
+ * 🛑 NOT reused from `CATEGORY_FIELDS`. `audit-route-nav-field-constants`
+ * suggested `CATEGORY_FIELDS.NAME` for a query against `partGlossary`, and the
+ * string would have been identical — which is exactly why that would be the
+ * wrong fix. A constant's job is to say WHICH collection's field is meant, so
+ * that renaming one collection's field cannot silently retarget another's
+ * query. Same bytes, different claim.
+ */
+/**
+ * `modelComposition` — which parts a model is built from.
+ *
+ * 🛑 ITS OWN `CATEGORY_ID`, not `BEY_FIELDS.CATEGORY_ID`. The audit suggested
+ * the bey constant for a query against THIS collection, and the string is
+ * identical — which is precisely the substitution the comment on
+ * `PART_GLOSSARY_FIELDS` warns about. A composition row's `categoryId` points
+ * at the model leaf it describes; a bey's points at its own paired leaf. Same
+ * bytes, two different facts, and only one of them moves if either is renamed.
+ */
+export const MODEL_COMPOSITION_FIELDS = {
+    ID: "id",
+    CATEGORY_ID: "categoryId",
+    SLOT: "slot",
+};
+export const PART_GLOSSARY_FIELDS = {
+    ID: "id",
+    NAME: "name",
+    SLOT: "slot",
+    CLASSIFICATION: "classification",
+    CODE: "code",
+    WEIGHT_G: "weightG",
+    /** Set by `applyAdminEdit`; the seed loader queries on it. */
+    ADMIN_EDITED: "adminEdited",
+    ADMIN_EDITED_FIELDS: "adminEditedFields",
+};
+export const BEY_FIELDS = {
+    ID: "id",
+    SLUG: "slug",
+    NAME: "name",
+    TYPE: "type",
+    SYSTEM: "system",
+    CATEGORY_ID: "categoryId",
+    ADMIN_EDITED: "adminEdited",
+    ADMIN_EDITED_FIELDS: "adminEditedFields",
+};
 export const CATEGORY_FIELDS = {
     ID: "id",
     NAME: "name",

package/dist/features/admin/components/AdminBeysView.d.ts

@@ -0,0 +1,27 @@
+/**
+ * AdminBeysView — browse and correct the generated Beyblade database.
+ *
+ * ── 🛑 WHY THIS IS A CORRECTION SURFACE, NOT A CRUD SCREEN ────────────────
+ *
+ * `beys` is 1,988 rows built by committed generators from a crawled corpus. So
+ * there is no "Add Beyblade" button: a row authored here would have no source,
+ * would vanish on the next regeneration, and would make the claim "this dataset
+ * rebuilds from `appkit/src/seed/` alone" false. Adding one is a change to the
+ * generator.
+ *
+ * What this surface IS for is the thing the corpus demonstrably needs — fixing
+ * a wrong extraction. On mode data alone the source was wrong five times in one
+ * session: an inverted tip transition, a mechanism attributed to the wrong
+ * part, a part with no modes at all, and two misexpanded abbreviations. A
+ * correction made here survives the next reseed, field by field
+ * (`adminEditedFields`).
+ *
+ * @tag domain:beys
+ * @tag layer:feature
+ * @tag access:client
+ * @tag consumers:app/[locale]/admin/beys/page.tsx
+ */
+import React from "react";
+import type { ListingLayoutProps } from "../../../ui";
+export type AdminBeysViewProps = ListingLayoutProps;
+export declare function AdminBeysView({ children, ...props }: AdminBeysViewProps): React.JSX.Element;