@mohasinac/appkit 4.57.0 → 4.59.0

package/dist/features/beys/components/BeyDetailPageView.js

@@ -0,0 +1,98 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Section, Container, Stack, Row, Div, Heading, Text, Span, TextLink, Anchor, Badge, } from "../../../ui/index.js";
+import { SpecTable } from "../../../ui/components/SpecTable.js";
+import { ROUTES } from "../../../next/routing/route-map.js";
+import { PART_SLOT_LABEL } from "../../parts/schemas/firestore.js";
+import { RecordOwnerQuickActions } from "../../admin/components/RecordOwnerQuickActions.js";
+/**
+ * The rating axes, in a fixed order.
+ *
+ * 🛑 ORDERED EXPLICITLY, never by `Object.keys`. Firestore returns map fields
+ * alphabetically, which would put "burst" and "dash" above "attack" and
+ * reorder the table per bey depending on which axes it happens to carry — so
+ * two beys could not be compared row against row.
+ */
+const RATING_AXES = [
+    { key: "attack", label: "Attack" },
+    { key: "defense", label: "Defense" },
+    { key: "stamina", label: "Stamina" },
+    { key: "weight", label: "Weight" },
+    { key: "speed", label: "Speed" },
+    { key: "burst", label: "Burst" },
+    { key: "burstResistance", label: "Burst resistance" },
+    { key: "dash", label: "Dash" },
+    { key: "power", label: "Power" },
+    { key: "height", label: "Height" },
+    { key: "runTime", label: "Run time" },
+];
+export function BeyDetailPageView({ bey, products, listings, listingsTruncated, allListingsHref, hrefForPart, categoryHref, hrefForCharacter, }) {
+    /*
+     * ── THE SPEC TABLE ────────────────────────────────────────────────────────
+     *
+     * Only what the source states. 🛑 A row is omitted when the fact is absent
+     * rather than rendered with an em-dash: "Element —" would claim we looked it
+     * up and found none, and `element` is on 45 of 1,988 beys precisely because
+     * it is a Beyblade-X-only attribute, not missing data.
+     */
+    const specRows = [
+        ...(bey.type ? [{ name: "Type", value: bey.type }] : []),
+        ...(bey.spinDirection ? [{ name: "Spin", value: bey.spinDirection }] : []),
+        ...(bey.system ? [{ name: "System", value: bey.system }] : []),
+        ...(bey.series ? [{ name: "Series", value: bey.series }] : []),
+        ...(bey.element ? [{ name: "Element", value: bey.element }] : []),
+        /*
+         * 🛑 MASS: the stated figure wins, and a SUMMED one is labelled as summed
+         * and marked approximate when the parts are only partly weighed. Printing
+         * a partial sum as a plain total is the one thing this must not do — the
+         * generator deliberately refuses to scale it up for the same reason.
+         */
+        ...(typeof bey.weightG === "number"
+            ? [{ name: "Weight", value: String(bey.weightG), unit: "g" }]
+            : typeof bey.weightGFromParts === "number"
+                ? [
+                    {
+                        name: "Weight",
+                        value: String(bey.weightGFromParts),
+                        unit: bey.weightGFromPartsCoverage?.complete
+                            ? "g (summed from parts)"
+                            : `g (from ${bey.weightGFromPartsCoverage?.weighed ?? 0} of ` +
+                                `${bey.weightGFromPartsCoverage?.total ?? 0} parts)`,
+                        approximate: !bey.weightGFromPartsCoverage?.complete,
+                    },
+                ]
+                : []),
+        ...(bey.productCodes?.length
+            ? [{ name: bey.productCodes.length > 1 ? "Product codes" : "Product code", value: bey.productCodes.join(" · ") }]
+            : []),
+        ...(bey.releaseJP ? [{ name: "Released (JP)", value: bey.releaseJP }] : []),
+        ...(bey.releaseUS ? [{ name: "Released (US)", value: bey.releaseUS }] : []),
+        ...(bey.jpName ? [{ name: "Japanese name", value: bey.jpName }] : []),
+        ...(bey.romaji ? [{ name: "Romaji", value: bey.romaji }] : []),
+        ...(bey.creator ? [{ name: "Creator", value: bey.creator }] : []),
+    ];
+    const ratings = bey.ratingsFromParts ?? null;
+    const ratingRows = ratings
+        ? RATING_AXES.map((a) => ({ ...a, value: ratings[a.key] })).filter((r) => typeof r.value === "number")
+        : [];
+    const composition = bey.composition ?? [];
+    const aliases = (bey.aka ?? []).filter((a) => a && a !== bey.name);
+    return (_jsx(Section, { padding: "y-lg", children: _jsx(Container, { size: "lg", children: _jsxs(Stack, { gap: "lg", className: "min-w-0", children: [_jsxs(Stack, { gap: "xs", className: "min-w-0", children: [categoryHref && (_jsx(Text, { size: "sm", color: "muted", children: _jsx(TextLink, { href: categoryHref, children: "Listings for this model" }) })), _jsx(Heading, { level: 1, children: bey.name }), _jsx(RecordOwnerQuickActions, { resource: "BEY", recordId: bey.id, placement: "detail", recordLabel: bey.name }), _jsxs(Row, { gap: "xs", wrap: true, align: "center", className: "min-w-0", children: [bey.type && _jsx(Badge, { variant: "info", children: bey.type }), bey.spinDirection && _jsx(Badge, { variant: "default", children: bey.spinDirection }), bey.system && _jsx(Badge, { variant: "secondary", children: bey.system })] }), aliases.length > 0 && (_jsxs(Text, { size: "sm", color: "muted", children: ["Also known as: ", aliases.join(" · ")] }))] }), composition.length > 0 && (_jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsx(Heading, { level: 2, size: "lg", children: "Parts" }), _jsx(Stack, { gap: "xs", className: "min-w-0", children: composition.map((c, i) => {
+                                    const href = c.partId ? hrefForPart(c.partId) : null;
+                                    const label = PART_SLOT_LABEL[c.slot] ?? c.slot;
+                                    return (_jsxs(Row, { gap: "md", align: "center", className: "min-w-0", children: [_jsx(Text, { size: "sm", color: "muted", className: "w-36 flex-shrink-0", children: label }), href ? (_jsx(TextLink, { href: href, children: c.partName })) : (_jsx(Span, { children: c.partName }))] }, `${c.slot}-${c.partName}-${i}`));
+                                }) })] })), ratingRows.length > 0 && (_jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsx(Heading, { level: 2, size: "lg", children: "Ratings" }), _jsx(SpecTable, { rows: ratingRows.map((r) => ({ name: r.label, value: String(r.value) })) }), _jsxs(Text, { size: "xs", color: "faint", children: ["Averaged from this bey\u2019s parts and rescaled to 0\u2013100 for comparison across generations", bey.ratingsFromPartsCoverage
+                                        ? `; from ${bey.ratingsFromPartsCoverage.rated ?? 0} of ` +
+                                            `${bey.ratingsFromPartsCoverage.total} parts`
+                                        : "", "."] })] })), bey.modes?.length ? (_jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsx(Heading, { level: 2, size: "lg", children: "Modes" }), _jsx(Stack, { gap: "md", className: "min-w-0", children: bey.modes.map((mode) => (_jsxs(Stack, { gap: "xs", className: "min-w-0", children: [_jsxs(Row, { gap: "sm", align: "center", wrap: true, className: "min-w-0", children: [_jsx(Text, { weight: "semibold", children: mode.name }), _jsx(Text, { size: "xs", color: "muted", children: mode.switchKind === "speed" || mode.switchKind === "impact"
+                                                        ? "changes on its own"
+                                                        : "set before launch" })] }), _jsx(Text, { size: "sm", children: mode.behaviour }), _jsx(Text, { size: "sm", color: "muted", children: mode.trigger })] }, mode.name))) })] })) : null, (bey.ownerNames?.length || bey.specialMoves?.length || bey.appearAnime) && (_jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsx(Heading, { level: 2, size: "lg", children: "In the anime" }), _jsx(SpecTable, { rows: [
+                                    ...(bey.ownerNames?.length
+                                        ? [{ name: "Used by", value: bey.ownerNames.join(" · ") }]
+                                        : []),
+                                    ...(bey.appearAnime ? [{ name: "First appearance", value: bey.appearAnime }] : []),
+                                    ...(bey.appearManga ? [{ name: "In the manga", value: bey.appearManga }] : []),
+                                    ...(bey.specialMoves?.length
+                                        ? [{ name: "Special moves", value: bey.specialMoves.join(" · ") }]
+                                        : []),
+                                ] }), hrefForCharacter && (bey.ownerCharacters?.length ?? 0) > 0 && (_jsx(Row, { gap: "xs", wrap: true, align: "center", className: "min-w-0", children: bey.ownerCharacters.map((slug) => (_jsx(TextLink, { href: hrefForCharacter(slug), children: slug.replace(/-/g, " ") }, slug))) }))] })), specRows.length > 0 && (_jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsx(Heading, { level: 2, size: "lg", children: "Specifications" }), _jsx(SpecTable, { rows: specRows })] })), products.length > 0 && (_jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsx(Heading, { level: 2, size: "lg", children: "Found in" }), _jsx(Stack, { gap: "xs", className: "min-w-0", children: products.map((p) => (_jsxs(Row, { gap: "md", align: "center", className: "min-w-0", children: [_jsx(Span, { children: p.name }), p.productType && (_jsx(Text, { size: "xs", color: "muted", children: p.productType }))] }, p.id))) })] })), _jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsx(Heading, { level: 2, size: "lg", children: listings.length > 0 ? "Currently listed" : "Listings" }), listings.length === 0 ? (_jsx(Text, { color: "muted", size: "sm", children: "Nothing matching this model is listed right now." })) : (_jsx(Stack, { gap: "xs", className: "min-w-0", children: listings.map((l) => (_jsxs(Row, { gap: "md", align: "center", className: "min-w-0", children: [_jsx(TextLink, { href: l.href, children: l.title }), l.condition && (_jsx(Text, { size: "xs", color: "muted", children: l.condition }))] }, l.id))) })), _jsx(Text, { size: "sm", children: _jsx(TextLink, { href: allListingsHref, children: listingsTruncated ? "See all listings" : "Search listings for this model" }) })] }), _jsx(Div, { children: _jsxs(Text, { size: "xs", color: "faint", children: ["Facts on this page are drawn from a community wiki under CC\u00A0BY-SA.", " ", _jsx(Anchor, { href: bey.sourceUrl, tone: "muted", underline: "always", children: "Source" }), bey.wboThreadUrl ? (_jsxs(_Fragment, { children: [" · ", _jsx(Anchor, { href: bey.wboThreadUrl, tone: "muted", underline: "always", children: "Community discussion" })] })) : null, " · ", _jsx(TextLink, { href: String(ROUTES.PUBLIC.CREDITS), children: "Credits" })] }) })] }) }) }));
+}

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

@@ -0,0 +1,417 @@
+/**
+ * The `beys` and `beyProducts` collections — the BEY reference database.
+ *
+ * Extracted from a crawled corpus by committed scripts and generated into the
+ * seed; nothing here is hand-typed. 1,988 beys and 366 products.
+ *
+ * ── 🛑 WHY THIS MIRRORS `partGlossary` RATHER THAN INVENTING A SHAPE ───────
+ *
+ * Parts already do all three halves of this and have for months: a
+ * `partGlossary` collection, a category leaf per part, and a
+ * `/parts/{classification}/{code}` reference page. Beys get the same three,
+ * so every decision that was already argued out there is inherited rather
+ * than re-litigated:
+ *
+ *   · the ID IS THE SLUG, shared with the category leaf (`category-{slug}`),
+ *     because one key across two collections is what keeps a reference page
+ *     and a commerce shelf pointing at the same thing;
+ *   · measured data lives HERE, not on `categories`, because
+ *     `handleCategoryWrite` calls `notifyRevalidate` unconditionally — so a
+ *     reseed of bey facts would drop every bey page's ISR entry on a project
+ *     that has already been paused at 15.5x its ISR cap;
+ *   · and a bey page is a REFERENCE surface, so it carries no money. Prices
+ *     are gated for signed-out visitors, which would make the page a client
+ *     component (see `PartDetailPageView`'s header).
+ *
+ * ── 🛑 NO `searchTxt` FIELD, DELIBERATELY ─────────────────────────────────
+ *
+ * `partGlossary` had one and it was REMOVED; the collection is declared
+ * `INDEX_ARTIFACT_ONLY` in `audit-searchtxt-migration`, whose rule is that a
+ * member must not declare the field. Beys are the same kind of collection —
+ * discovery happens through the category leaf, which has its own `searchTxt`
+ * built from the leaf's name and aliases.
+ */
+import type { AdminEditableRecord } from "../../parts/schemas/admin-edit";
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
+export declare const BEYS_COLLECTION: "beys";
+export declare const BEY_PRODUCTS_COLLECTION: "beyProducts";
+/**
+ * One slot of a bey's build.
+ *
+ * 🛑 `partName` is kept EVEN WHEN `partId` resolves, and that is not
+ * redundancy. The join reaches 88.9% of 7,688 links, so ~850 entries name a
+ * part we hold no row for — and a slot that renders nothing reads as a bey
+ * with an incomplete build rather than as a missing part page. The name is
+ * what the source stated; the id is what we managed to resolve.
+ */
+export interface BeyCompositionEntry {
+    /** Our canonical slot key — `fusion-wheel`, `performance-tip`, `driver`. */
+    slot: string;
+    /** The part as the source names it, which is sometimes an abbreviation. */
+    partName: string;
+    /** `partGlossary` id, when the name or one of its aliases resolved. */
+    partId?: string;
+    /**
+     * The raw infobox key this came from.
+     *
+     * 🛑 Load-bearing for Synchrome, where `WarriorWheel2=Behemoth` is the
+     * OTHER HALF of a two-wheel combination rather than a duplicate key to
+     * dedupe. Two entries can share a `slot` and still be distinct parts.
+     */
+    infoboxKey?: string;
+}
+/** The 0-100 rating vector. Same axes as `PartRatings`, same scale. */
+export interface BeyRatings {
+    attack?: number;
+    defense?: number;
+    stamina?: number;
+    weight?: number;
+    speed?: number;
+    burst?: number;
+    burstResistance?: number;
+    dash?: number;
+    power?: number;
+    height?: number;
+    runTime?: number;
+}
+/**
+ * How much of a derived figure is actually measured.
+ *
+ * 🛑 This rides WITH every derived value and is not optional decoration. A
+ * vector built from 2 of 5 parts is a different claim from one built from 5 of
+ * 5, and a mass summed from 3 weighed parts out of 5 is a floor rather than a
+ * total. Without this a consumer cannot tell them apart, and the honest
+ * rendering ("≈", or nothing at all) becomes impossible.
+ */
+export interface BeyDerivationCoverage {
+    /** Parts contributing a value. */
+    rated?: number;
+    weighed?: number;
+    /** Parts in the composition. */
+    total: number;
+    /** True only when every part contributed. */
+    complete?: boolean;
+}
+/**
+ * One configuration a bey can be set to, or settles into.
+ *
+ * ── 🛑 THERE IS NO THRESHOLD FIELD, AND THAT IS DELIBERATE ────────────────
+ *
+ * Mode data exists only in the local case-study corpus (the wiki carries ZERO:
+ * 0 `Modes=` fields across 2,248 part pages and 2,011 bey pages), and every
+ * numeric threshold cross-checked there DISAGREED across sources. Cosmic
+ * Pegasus F:D is documented twice with the transition running in opposite
+ * directions and three different thresholds between the two cases and the plan.
+ *
+ * So a `thresholdRadPerSec` does not exist here. A field that is absent cannot
+ * be filled with a contested number by someone who assumes the gap was an
+ * oversight — which is why this is a schema decision and not a convention.
+ *
+ * 🛑 `trigger` is FREE TEXT, not an enum. The three authored shapes are
+ * already a pre-launch setting, passive spin decay, and what surface the tip
+ * is running on — and a three-value enum written before the fourth case was
+ * read would have forced the next one into the wrong bucket.
+ */
+/**
+ * How a mode is selected.
+ *
+ * ── 🛑 THIS ENUM IS THE OWNER'S TAXONOMY, NOT MY GUESS ────────────────────
+ *
+ * Owner, 2026-10-21: *"most mode switches are either flips, config 1, 2 or 3
+ * and more."* Everything beyond that set is a mode that changes WITHOUT the
+ * owner doing anything, and those divide cleanly by what drives them.
+ *
+ * I deliberately did NOT define this when the first four modes were authored,
+ * because at that point I had seen two kinds and an enum built from two would
+ * have forced the next two into the wrong value. It is defined now that the
+ * real set is known — which is the difference between a taxonomy and a guess.
+ */
+export declare const BEY_MODE_SWITCH_KINDS: readonly ["flip", "config", "swap", "speed", "impact"];
+export type BeyModeSwitchKind = (typeof BEY_MODE_SWITCH_KINDS)[number];
+/** One configuration a bey can be set to, or settles into. */
+export interface BeyMode {
+    /** "Attack", "Stamina", "Barrage". The part's own vocabulary where it has one. */
+    name: string;
+    /** What it does, in a sentence a buyer can read. No formulae. */
+    behaviour: string;
+    /**
+     * How it comes about, in prose. 🛑 Kept ALONGSIDE `switchKind` rather than
+     * replaced by it: the kind is what a filter or a game reads, the sentence is
+     * what a person reads, and "Assemble the wheel for six contact points" is
+     * not recoverable from `"config"`.
+     */
+    trigger: string;
+    /** Which of the six selection mechanisms this is. */
+    switchKind?: BeyModeSwitchKind;
+    /** 1-based, for `switchKind: "config"` / `"swap"`. */
+    configIndex?: number;
+    /**
+     * The part that provides the mode — a fusion wheel or a tip in every case
+     * confirmed so far.
+     *
+     * 🛑 Modes are authored against the PART and fanned out to every bey whose
+     * composition uses it, so one wheel is described once rather than copied per
+     * bey (Root Cause #75). This field keeps that origin visible on the bey, and
+     * is what would let a later pass lift modes onto `partGlossary` mechanically.
+     */
+    appliesToPart?: string;
+    /**
+     * A second part the mode depends on, when it is an ALIGNMENT between two.
+     *
+     * 🛑 Not every mode belongs to one part. Lightning and Meteo L-Drago change
+     * mode by how the energy ring's dragon heads line up with the wheel's teeth
+     * — a property of the PAIR. Without this the data would claim the wheel
+     * alone does it.
+     */
+    requiresPart?: string;
+    /**
+     * Who or what the claim rests on — `"owner-<date>"` for a confirmed one.
+     *
+     * 🛑 LOAD-BEARING, not metadata. The generator emits ONLY modes carrying
+     * this, because the case-study corpus's mode prose was wrong in four of four
+     * claims reviewed. See `scripts/lib/bey-modes-authored.mjs`.
+     */
+    confirmed?: string;
+    /** The case-study case number, where one was read. A claim nobody can trace is a claim nobody can correct. */
+    sourceCase?: number;
+}
+export interface BeyDocument extends BaseDocument, AdminEditableRecord {
+    /** `id === slug`, and the same slug the category leaf uses. */
+    id: string;
+    slug: string;
+    name: string;
+    /** Battle type as stated — `Attack`, `Balance`, `Defense`, `Stamina`. */
+    type?: string;
+    /** `Right-Spin` / `Left-Spin` / `Dual-Spin`. */
+    spinDirection?: string;
+    /**
+     * The hardware generation — `4D System`, `Hybrid Wheel System`, `Basic
+     * Line`. 1,893 of 1,988.
+     *
+     * 🛑 This is the within-generation assembly key. No bey can be built across
+     * generations, and Plastic and HMS do not interchange either, so a build
+     * validator needs it. It is also what files the bey under a forest line
+     * (`scripts/lib/bey-system-to-line.mjs`).
+     */
+    system?: string;
+    /** A second system, for the handful of releases that span two. */
+    system2?: string;
+    /** The retail series — `Beyblade Burst QuadStrike`. */
+    series?: string;
+    series2?: string;
+    /**
+     * The paired tier-4 category leaf — where this model's LISTINGS live.
+     *
+     * 🛑 NOT derivable from `slug`. The leaf id comes from the bey's NAME with
+     * the trailing parenthetical stripped, so `…-press-hasbro` pairs with
+     * `category-…-press`; guessing would 404 on every vendor-qualified bey.
+     * Resolved by the generator with the leaf generator's own helper and then
+     * CHECKED against the leaves it emitted, so this is present only when the
+     * page really exists — 116 beys have no leaf because their `system` is
+     * deliberately unmapped.
+     */
+    categoryId?: string;
+    /** The build, top to bottom. 1,911 of 1,988 carry one. */
+    composition?: BeyCompositionEntry[];
+    /**
+     * 🛑 DERIVED AND AVERAGED, never summed, and never the raw source numbers.
+     *
+     * Two rating scales live in the part data — Beyblade X rates 0-100 and
+     * everything before it rates 0-6 — so these are averaged over each part's
+     * NORMALISED vector. A sum would make a five-part bey look five times
+     * stronger than a three-part one, which is backwards: more parts is not
+     * more attack.
+     */
+    ratingsFromParts?: BeyRatings;
+    ratingsFromPartsCoverage?: BeyDerivationCoverage;
+    /**
+     * Configurations this bey can be set to. **4 of 1,988 carry this.**
+     *
+     * 🛑 ABSENT, NEVER `[]`. An empty array says "this bey has no modes" to
+     * every consumer; absent says "unknown", which is the truth for 1,984 of
+     * them. Do not default it, and do not treat its absence as a gap to fill
+     * mechanically — see `scripts/lib/bey-modes-authored.mjs` for what the
+     * corpus can and cannot support, including the one bey excluded because its
+     * two sources contradict each other outright.
+     *
+     * Most of the corpus's mode content is about PARTS, not beys (135 of 147
+     * candidates were part-level analyses), so the bulk of it belongs on
+     * `partGlossary` if it is ever modelled at all.
+     */
+    modes?: BeyMode[];
+    /** Mass as the source states it. Only 248 of 1,988 do. */
+    weightG?: number;
+    /**
+     * Mass SUMMED from the parts — 1,593 beys, 775 from a complete set.
+     *
+     * 🛑 A DIFFERENT KIND OF CLAIM from the ratings above, and the difference is
+     * why it is safe: mass is physically additive, so a sum is a measurement.
+     * Held-out validated against the 164 beys that state their own mass —
+     * median absolute error 0.00 g, 99% within 2 g.
+     *
+     * 🛑 Never scaled up from partial coverage. 3 of 5 parts weighed gives the
+     * mass of those three; inflating it by 5/3 would invent a figure that reads
+     * exactly like a measured one. And a stated `weightG` always wins.
+     */
+    weightGFromParts?: number;
+    weightGFromPartsCoverage?: BeyDerivationCoverage;
+    /** Box codes. `productCodes[0]` is the one printed on the box. */
+    productCodes?: string[];
+    /**
+     * Every other name this bey ships under — 1,327 of 1,988.
+     *
+     * 🛑 This is the Hasbro ↔ Takara-Tomy map, stated by the source rather than
+     * inferred: Valkyrie/Valtryek, Spriggan/Spryzen. It must NOT be used to
+     * merge two rows — `Dead` and `Dread` are two real Gatinko bases one
+     * character apart, so any name-similarity join on this corpus is
+     * disqualified.
+     */
+    aka?: string[];
+    jpName?: string;
+    romaji?: string;
+    kanjiName?: string;
+    krName?: string;
+    releaseJP?: string;
+    releaseUS?: string;
+    releaseCA?: string;
+    releaseKR?: string;
+    /** As stated, in the source's own currency and formatting. */
+    price?: string;
+    /** The owner string verbatim, qualifiers and all. */
+    owner?: string;
+    /** Each person named, cleaned and split. */
+    ownerNames?: string[];
+    /**
+     * Character slugs that resolved exactly — 661 of the 733 with an owner.
+     *
+     * 🛑 Resolved by stripping a stated qualifier and matching EXACTLY, never
+     * approximately. `owner` keeps the raw string because "(manga)" is a real
+     * distinction: that bey belongs to that character in the manga continuity
+     * only.
+     */
+    ownerCharacters?: string[];
+    creator?: string;
+    specialMoves?: string[];
+    /** First anime appearance, as the source names the episode. */
+    appearAnime?: string;
+    appearManga?: string;
+    animeDebut?: string;
+    /** Beyblade-X-only attribute. 45 of 1,988 — not worth a facet. */
+    element?: string;
+    avatar?: string;
+    toyline?: string;
+    /** Image filenames, resolved to `/media/<shortId>` at upload time. */
+    /**
+     * `lead` marks the one image to show first. Optional because a hand-written
+     * row may omit it and absent reads as false; the generator sets it on all
+     * 2,459 entries, so no reader is relying on the default today.
+     */
+    images?: {
+        file: string;
+        label?: string | null;
+        lead?: boolean;
+    }[];
+    /** Our own prose, composed from the facts above. */
+    seoDescription?: string;
+    /**
+     * The source page.
+     *
+     * 🛑 REQUIRED, and it must reach the UI. The corpus is CC-BY-SA, and the
+     * two things that keep us clear of share-alike are taking facts only and
+     * linking back. It was stored on ~5,500 rows and rendered on NONE of them
+     * until the credits work; storing it is not discharging the obligation.
+     */
+    sourceUrl: string;
+    /** How the row was obtained — `fandom-infobox`. */
+    source?: string;
+    /** Community discussion thread, where the source links one. */
+    wboThreadUrl?: string;
+}
+/** One assortment slot of a product — a bey a buyer might get. */
+export interface BeyProductAssortmentEntry {
+    /** The bey as the source names it. */
+    bey: string;
+    /** Resolved `beys` id, when the name matched. */
+    beyId?: string;
+    /** A prize bey is not purchasable — it is drawn. */
+    isPrize?: boolean;
+    /** Stated pull odds, where the source gives them. */
+    odds?: string;
+    /**
+     * The manufacturer's per-item code within the assortment ("B-101 01"), where
+     * the source lists one. Distinct from the PRODUCT's own code: a random
+     * booster has one code and a different one per bey you can pull from it.
+     */
+    itemCode?: string;
+    /** This bey debuts in the set, rather than being a repackaged earlier release. */
+    newToSeries?: boolean;
+}
+/**
+ * One image in a product's gallery.
+ *
+ * `caption` is optional-AND-nullable, mirroring `BeyDocument.images[].label`
+ * beside it: the generator emits the key on all 1,457 entries and leaves 292
+ * of them `null`, while a hand-written row may simply omit it. Both are "no
+ * caption", and the type accepts both rather than forcing one spelling on a
+ * generator that already chose the other.
+ */
+/** One line of a product's per-carton distribution table. */
+export interface BeyProductCartonEntry {
+    /** The bey as the source names it — matches `BeyProductAssortmentEntry.bey`. */
+    bey: string;
+    /** How many of this bey ship in one sealed carton. */
+    perCarton: number;
+}
+export interface BeyProductGalleryImage {
+    /** Source filename, as the corpus names it — not a `/media/` slug yet. */
+    file: string;
+    caption?: string | null;
+}
+export interface BeyProductDocument extends BaseDocument {
+    id: string;
+    slug: string;
+    name: string;
+    /** `Random Booster`, `Battle Set`, `Starter`, `Stadium`. */
+    productType?: string;
+    productCodes?: string[];
+    price?: string;
+    releaseJP?: string;
+    jpName?: string;
+    romaji?: string;
+    /** What is in the box, or what can be pulled from it. */
+    assortment?: BeyProductAssortmentEntry[];
+    /**
+     * Every resolved `beys` id in `assortment`, flat.
+     *
+     * 🛑 A denormalised MIRROR of `assortment[].beyId`, and it exists for one
+     * reason: Firestore cannot `array-contains` a field nested inside objects
+     * in an array, so "which products contain this bey" is otherwise
+     * unanswerable. Derived by the generator in the same pass that resolves the
+     * ids — never hand-maintained, because a mirror somebody can edit
+     * independently is the drift in Root Cause #42.
+     */
+    assortmentBeyIds?: string[];
+    /**
+     * Per-carton distribution, on the 24 products whose source states one.
+     *
+     * 🛑 An ARRAY, not the `Record<string, string>` this was declared as. A map
+     * keyed on the bey name cannot hold two entries for the same name, and it
+     * loses the source's ordering — both of which the carton tables rely on.
+     * Measured across all 24: 137 entries, every one carrying both keys.
+     */
+    breakdown?: BeyProductCartonEntry[];
+    boxImage?: string;
+    gallery?: BeyProductGalleryImage[];
+    seoDescription?: string;
+    /** CC-BY-SA link-back — see `BeyDocument.sourceUrl`. */
+    sourceUrl: string;
+    source?: string;
+}
+/**
+ * The document id for a bey.
+ *
+ * 🛑 The ONE place this is composed, mirroring `partGlossaryId`. The id is
+ * also the slug, the public URL and a `searchTxt` source on the paired
+ * category leaf, so a second spelling of this rule is a second set of URLs.
+ */
+export declare function beyId(slug: string): string;

package/dist/features/beys/schemas/firestore.js

@@ -0,0 +1,65 @@
+export const BEYS_COLLECTION = "beys";
+export const BEY_PRODUCTS_COLLECTION = "beyProducts";
+/**
+ * One configuration a bey can be set to, or settles into.
+ *
+ * ── 🛑 THERE IS NO THRESHOLD FIELD, AND THAT IS DELIBERATE ────────────────
+ *
+ * Mode data exists only in the local case-study corpus (the wiki carries ZERO:
+ * 0 `Modes=` fields across 2,248 part pages and 2,011 bey pages), and every
+ * numeric threshold cross-checked there DISAGREED across sources. Cosmic
+ * Pegasus F:D is documented twice with the transition running in opposite
+ * directions and three different thresholds between the two cases and the plan.
+ *
+ * So a `thresholdRadPerSec` does not exist here. A field that is absent cannot
+ * be filled with a contested number by someone who assumes the gap was an
+ * oversight — which is why this is a schema decision and not a convention.
+ *
+ * 🛑 `trigger` is FREE TEXT, not an enum. The three authored shapes are
+ * already a pre-launch setting, passive spin decay, and what surface the tip
+ * is running on — and a three-value enum written before the fourth case was
+ * read would have forced the next one into the wrong bucket.
+ */
+/**
+ * How a mode is selected.
+ *
+ * ── 🛑 THIS ENUM IS THE OWNER'S TAXONOMY, NOT MY GUESS ────────────────────
+ *
+ * Owner, 2026-10-21: *"most mode switches are either flips, config 1, 2 or 3
+ * and more."* Everything beyond that set is a mode that changes WITHOUT the
+ * owner doing anything, and those divide cleanly by what drives them.
+ *
+ * I deliberately did NOT define this when the first four modes were authored,
+ * because at that point I had seen two kinds and an enum built from two would
+ * have forced the next two into the wrong value. It is defined now that the
+ * real set is known — which is the difference between a taxonomy and a guess.
+ */
+export const BEY_MODE_SWITCH_KINDS = [
+    /** Turn the part over. Two states by definition. */
+    "flip",
+    /** An indexed assembly position — config 1, 2, 3… See `configIndex`. */
+    "config",
+    /** Swap in a different piece (Delta Drive's three tips). */
+    "swap",
+    /** Changes on its own as spin speed falls. Nothing to set. */
+    "speed",
+    /** Fires when the bey is struck (Kreis' halves slipping). */
+    "impact",
+    /*
+     * 🛑 There is deliberately NO "surface" kind. Its only candidate was the
+     * claim that Bandit Genbu's TB tip runs on a ball or a cylinder rim
+     * depending on the floor — and TB is "Tapered Ball", a FIXED SHAPE with no
+     * modes at all (owner, 2026-10-21). An enum value whose only instance turned
+     * out not to exist is the speculative infra this project forbids.
+     */
+];
+/**
+ * The document id for a bey.
+ *
+ * 🛑 The ONE place this is composed, mirroring `partGlossaryId`. The id is
+ * also the slug, the public URL and a `searchTxt` source on the paired
+ * category leaf, so a second spelling of this rule is a second set of URLs.
+ */
+export function beyId(slug) {
+    return slug;
+}

package/dist/features/blog/components/BlogFeaturedCard.js

@@ -6,6 +6,7 @@ import { getMediaUrl } from "../../media/types/index.js";
 import { getDefaultLocale } from "../../../core/baseline-resolver.js";
 import { safeDisplayName } from "../../../security/index.js";
 import { useLongPress } from "../../../react/hooks/useLongPress.js";
+import { RecordOwnerQuickActions } from "../../admin/components/RecordOwnerQuickActions.js";
 const __P = {
     p4: "p-[var(--appkit-space-4)]",
 };
@@ -32,11 +33,23 @@ export function BlogFeaturedCard({ post, href, labels = {}, className = "", sele
         })
         : "";
     const card = (_jsxs(Article, { rounded: "xl", shadow: "hover-md", className: `group relative h-full overflow-hidden border border-[var(--appkit-color-border)] bg-[var(--appkit-color-surface)] ${isSelected ? "ring-2 ring-primary outline outline-2 outline-primary" : ""} ${className}`, onMouseDown: onSelect && !isSelected ? longPress.onMouseDown : undefined, onMouseUp: onSelect && !isSelected ? longPress.onMouseUp : undefined, onMouseLeave: onSelect && !isSelected ? longPress.onMouseLeave : undefined, onTouchStart: onSelect && !isSelected ? longPress.onTouchStart : undefined, onTouchEnd: onSelect && !isSelected ? longPress.onTouchEnd : undefined, onTouchCancel: onSelect && !isSelected ? longPress.onTouchCancel : undefined, children: [onSelect && (_jsx(BaseListingCard.Checkbox, { selected: isSelected, onSelect: (e) => { e.preventDefault(); onSelect(post.id, !isSelected); }, label: isSelected ? "Deselect post" : "Select post", position: "top-2 left-2", className: selectable || isSelected ? "opacity-100" : "opacity-0 pointer-events-none group-hover:opacity-100 group-hover:pointer-events-auto transition-opacity" })), _jsxs(TextLink, { href: href, layout: "flex-col", className: "h-full", children: [showThumbnail && (_jsx(Div, { className: `relative aspect-video ${__O.hidden} flex-shrink-0`, children: coverImageUrl ? (_jsx(MediaImage, { src: coverImageUrl, alt: safeTitle, size: "card", className: "transition-transform duration-300 group-hover:scale-105" })) : (_jsx(Div, { role: "img", "aria-label": safeTitle, surface: "muted", className: "h-full w-full" })) })), _jsxs(Stack, { className: `flex-1 ${__P.p4}`, children: [_jsxs(Row, { gap: "xs", className: "mb-2", wrap: true, children: [_jsx(Span, { size: "xs", weight: "medium", className: `inline-block capitalize ${CATEGORY_BADGE[post.category] ?? "bg-[var(--appkit-color-bg)] text-[var(--appkit-color-text-muted)]"}`, rounded: "full", padding: "pill-xs", children: post.category }), post.isFeatured && (_jsx(Span, { size: "xs", weight: "medium", className: CLS_FEATURED_BADGE, children: labels.featuredBadge ?? "Featured" }))] }), _jsx(Heading, { level: 3, className: `leading-snug mb-1`, color: "primary", truncate: 2, size: "base", weight: "semibold", children: safeTitle }), post.excerpt && (_jsx(Text, { className: `mb-3`, color: "muted", truncate: 2, size: "sm", children: post.excerpt })), _jsxs(Row, { color: "muted", textSize: "xs", className: "mt-auto", gap: "3", wrap: true, children: [showAuthor && post.authorName && (_jsx(Span, { children: safeDisplayName(post.authorName, "Author") })), showReadTime && post.readTimeMinutes != null && (_jsxs(Span, { children: [post.readTimeMinutes, " ", labels.readTime ?? "min read"] })), date && _jsx(Span, { children: date })] })] })] })] }));
-    if (!renderOwnerActions)
+    /*
+     * 🛑 Default, not opt-in. Nothing in either repo ever passed
+     * `renderOwnerActions`, so this toolbar was unreachable on every grid that
+     * mounts this card (Root Cause #8 — a slot shell rendered with zero render
+     * props). A card is resource-specific by construction, so it names its own
+     * resource rather than being threaded one; the prop stays as an override.
+     */
+    const ownerActions = renderOwnerActions
+        ? renderOwnerActions()
+        : post.id
+            ? (_jsx(RecordOwnerQuickActions, { resource: "BLOG", recordId: String(post.id), recordLabel: post.title, placement: "card" }))
+            : null;
+    if (!ownerActions)
         return card;
     /*
      * Sibling of the card, never a child — see the prop's docstring. `z-20`
      * beats this card's own overlays, which all sit at `z-10`.
      */
-    return (_jsxs(Div, { className: "relative h-full", children: [card, _jsx(Div, { className: "absolute right-2 top-2 z-20", children: renderOwnerActions() })] }));
+    return (_jsxs(Div, { className: "relative h-full", children: [card, _jsx(Div, { className: "absolute right-2 top-2 z-20", children: ownerActions })] }));
 }

package/dist/features/blog/components/BlogPostView.js

@@ -11,7 +11,7 @@ import { getMediaUrl } from "../../media/types/index.js";
 import { getDefaultLocale } from "../../../core/baseline-resolver.js";
 import { normalizeRichTextHtml } from "../../../utils/string.formatter.js";
 import { ROUTES } from "../../../next/routing/route-map.js";
-import { OwnerQuickActions } from "../../admin/components/OwnerQuickActions.js";
+import { RecordOwnerQuickActions } from "../../admin/components/RecordOwnerQuickActions.js";
 const __P = {
     p8: "p-[var(--appkit-space-8)]",
 };
@@ -27,7 +27,7 @@ const CATEGORY_BADGE = {
 };
 const CLS_FEATURED_BADGE = "bg-warning-surface text-warning dark:bg-warning-surface dark:text-warning px-[var(--appkit-space-2)] py-[var(--appkit-space-0-5)] rounded-full";
 function renderBlogPostHeader(post, date, labels) {
-    return (_jsxs(Div, { className: "mb-8", children: [_jsxs(Row, { className: "mb-4", gap: "sm", children: [_jsx(Span, { size: "xs", weight: "medium", className: `inline-block capitalize ${CATEGORY_BADGE[post.category] ?? ""}`, rounded: "full", padding: "pill-xs", children: post.category }), post.isFeatured && _jsx(Span, { size: "xs", weight: "medium", className: CLS_FEATURED_BADGE, children: labels?.featured ?? "Featured" })] }), _jsxs(Row, { className: "mb-4", gap: "sm", align: "center", justify: "between", wrap: true, children: [_jsx(Heading, { level: 1, size: "3xl", weight: "bold", children: post.title }), _jsx(OwnerQuickActions, { resource: "BLOG", placement: "detail", editHref: String(ROUTES.ADMIN.BLOG_EDIT(post.id)), recordLabel: post.title })] }), post.excerpt && _jsx(Text, { className: "mb-6", color: "muted", size: "lg", children: post.excerpt }), _jsxs(Row, { color: "muted", textSize: "sm", wrap: true, gap: "md", children: [post.authorName && _jsxs(Span, { children: [labels?.author ?? "By", " ", _jsx(Span, { weight: "medium", color: "muted", children: post.authorName })] }), post.readTimeMinutes != null && _jsxs(Span, { children: [post.readTimeMinutes, " ", labels?.readTime ?? "min read"] }), date && _jsxs(Span, { children: [labels?.publishedOn ?? "Published", " ", date] }), post.views != null && _jsxs(Span, { children: [post.views, " ", labels?.viewsLabel ?? "views"] })] })] }));
+    return (_jsxs(Div, { className: "mb-8", children: [_jsxs(Row, { className: "mb-4", gap: "sm", children: [_jsx(Span, { size: "xs", weight: "medium", className: `inline-block capitalize ${CATEGORY_BADGE[post.category] ?? ""}`, rounded: "full", padding: "pill-xs", children: post.category }), post.isFeatured && _jsx(Span, { size: "xs", weight: "medium", className: CLS_FEATURED_BADGE, children: labels?.featured ?? "Featured" })] }), _jsxs(Row, { className: "mb-4", gap: "sm", align: "center", justify: "between", wrap: true, children: [_jsx(Heading, { level: 1, size: "3xl", weight: "bold", children: post.title }), _jsx(RecordOwnerQuickActions, { resource: "BLOG", recordId: post.id, placement: "detail", recordLabel: post.title })] }), post.excerpt && _jsx(Text, { className: "mb-6", color: "muted", size: "lg", children: post.excerpt }), _jsxs(Row, { color: "muted", textSize: "sm", wrap: true, gap: "md", children: [post.authorName && _jsxs(Span, { children: [labels?.author ?? "By", " ", _jsx(Span, { weight: "medium", color: "muted", children: post.authorName })] }), post.readTimeMinutes != null && _jsxs(Span, { children: [post.readTimeMinutes, " ", labels?.readTime ?? "min read"] }), date && _jsxs(Span, { children: [labels?.publishedOn ?? "Published", " ", date] }), post.views != null && _jsxs(Span, { children: [post.views, " ", labels?.viewsLabel ?? "views"] })] })] }));
 }
 function renderBlogPostRelated(related, title, renderRelatedCard) {
     if (related.length === 0)