@mohasinac/appkit 4.71.0 → 4.72.0

package/dist/features/parts/components/PartDetailPageView.js

@@ -1,123 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Section } from "../../../ui/components/Semantic.js";
-import { Container, Stack, Row } from "../../../ui/components/Layout.js";
-import { Div } from "../../../ui/components/Div.js";
-import { Heading, Text, Span } from "../../../ui/components/Typography.js";
-import { TextLink } from "../../../ui/components/TextLink.js";
-import { Badge } from "../../../ui/components/Badge.js";
-import { Anchor } from "../../../ui/components/Anchor.js";
-import { SpecTable } from "../../../ui/components/SpecTable.js";
-import { RecordOwnerQuickActions } from "../../admin/components/RecordOwnerQuickActions.js";
-import { ROUTES } from "../../../next/routing/route-map.js";
-import { PART_SLOT_LABEL, } from "../schemas/firestore.js";
-/**
- * The buyer-facing label for each WBO tournament format, in the order a
- * player cares about: the formats they are most likely to enter first.
- *
- * 🛑 A `Record` over the format keys rather than a derived title-case, because
- * "Burst Standard" is not `burstStandard` title-cased and "GT" must not become
- * "Gt". 1,380 of 2,488 parts carry a legality ruling.
- */
-const WBO_FORMAT_LABEL = {
-    burstStandard: "Burst Standard",
-    burstLimited: "Burst Limited",
-    burstClassic: "Burst Classic",
-    burstGT: "Burst GT",
-    burstSparking: "Burst Sparking",
-    burstDynamite: "Burst Dynamite",
-    xStandard: "X Standard",
-    zeroG: "Zero-G",
-    metalFight: "Metal Fight",
-    plastic: "Plastic",
-    hms: "HMS",
-};
-/**
- * The rating axes, in a fixed order.
- *
- * 🛑 ORDERED EXPLICITLY, never by `Object.keys`. Firestore returns map fields
- * alphabetically, which would put "burst" and "dash" ahead of "attack" and
- * reorder the table per part depending on which axes that part happens to
- * carry. A reader comparing two parts needs the same rows in the same places.
- */
-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 PartDetailPageView({ part, usedBy, listings, listingsTruncated, allListingsHref, exactListings = [], exactListingsTruncated, hrefForModel, hrefForClassification, }) {
-    const classification = PART_SLOT_LABEL[part.slot] ?? part.classification ?? part.slot;
-    /*
-     * 🛑 Only 23 of 753 parts carry a code, and that is a fact about the sources
-     * rather than missing data. So the code renders as a badge when present and
-     * nothing stands in for it when absent — an em-dash beside "Code" would
-     * imply we looked it up and found none.
-     */
-    const aliases = (part.aliases ?? []).filter((a) => a && a !== part.name && a !== part.code);
-    /*
-     * ── THE SPEC TABLE ────────────────────────────────────────────────────────
-     *
-     * `specs[]` is the extracted infobox (2,144 of 2,488 parts carry one), and
-     * the four rows prepended here are the fields promoted OFF that array
-     * because something queries them — so they would otherwise either be
-     * missing from the table or duplicated inside it.
-     *
-     * 🛑 De-duplicated against the extracted rows by label. `Classification`,
-     * `System` and `Series` all appear in `specs[]` as well, so prepending them
-     * blindly printed each one twice.
-     */
-    const promoted = [
-        { name: "Classification", value: classification },
-        ...(part.system ? [{ name: "System", value: part.system }] : []),
-        ...(part.series ? [{ name: "Series", value: part.series }] : []),
-        ...(typeof part.weightG === "number"
-            ? [{ name: "Weight", value: String(part.weightG), unit: "g" }]
-            : []),
-        ...(part.spinDirection ? [{ name: "Spin direction", value: part.spinDirection }] : []),
-        ...(part.partType ? [{ name: "Type", value: part.partType }] : []),
-        ...(part.hasbroCode ? [{ name: "Hasbro code", value: part.hasbroCode }] : []),
-    ];
-    const promotedLabels = new Set(promoted.map((r) => r.name.toLowerCase()));
-    const specRows = [
-        ...promoted,
-        ...(part.specs ?? [])
-            .filter((s) => s.label && s.value && !promotedLabels.has(s.label.toLowerCase()))
-            .map((s) => ({ name: s.label, value: s.value })),
-    ];
-    /*
-     * ── RATINGS ───────────────────────────────────────────────────────────────
-     *
-     * 🛑 RENDER THE NORMALISED VECTOR, NEVER THE RAW ONE. Two scales live in
-     * these fields — the Beyblade X lines rate 0-100 and everything before them
-     * rates 0-6 (with a handful of Burst systems peaking at 7 or 8) — so a raw
-     * "Attack 3" means half of maximum for a Burst part and almost nothing for
-     * an X part. `ratingsNormalised` is the only comparable form, and the source
-     * scale is stated under the bars so the number is not passed off as the
-     * wiki's own.
-     */
-    const ratings = part.ratingsNormalised ?? null;
-    const ratingRows = ratings
-        ? RATING_AXES.map((a) => ({ ...a, value: ratings[a.key] })).filter((r) => typeof r.value === "number")
-        : [];
-    /* Only the formats this part is actually ruled on — see the note below. */
-    const legalFormats = Object.entries(part.wboLegality ?? {}).filter(([, v]) => typeof v === "boolean");
-    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: [_jsx(Text, { size: "sm", color: "muted", children: _jsx(TextLink, { href: hrefForClassification(part.slot), children: classification }) }), _jsx(Heading, { level: 1, children: part.name }), _jsx(RecordOwnerQuickActions, { resource: "PART", recordId: part.id, placement: "detail", recordLabel: part.name }), _jsxs(Row, { gap: "xs", wrap: true, align: "center", className: "min-w-0", children: [part.code && _jsx(Badge, { variant: "info", children: part.code }), typeof part.weightG === "number" && (_jsxs(Badge, { variant: "default", children: [part.weightG, " g"] }))] }), aliases.length > 0 && (_jsxs(Text, { size: "sm", color: "muted", children: ["Also written: ", aliases.join(" · ")] }))] }), specRows.length > 1 && (_jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsx(Heading, { level: 2, size: "lg", children: "Specifications" }), _jsx(SpecTable, { rows: specRows })] })), 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: `${r.value} / 100`,
-                                })) }), _jsxs(Text, { size: "xs", color: "faint", children: ["Rescaled to 0\u2013100 for comparison across generations", typeof part.ratingScale === "number"
-                                        ? `; rated 0–${part.ratingScale} at source`
-                                        : "", "."] })] })), legalFormats.length > 0 && (_jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsx(Heading, { level: 2, size: "lg", children: "Tournament legality" }), _jsx(Row, { gap: "xs", wrap: true, align: "center", className: "min-w-0", children: legalFormats.map(([format, allowed]) => (_jsxs(Badge, { variant: allowed ? "success" : "danger", children: [WBO_FORMAT_LABEL[format] ?? format, allowed ? " ✓" : " ✗"] }, format))) }), _jsx(Text, { size: "xs", color: "faint", children: "World Beyblade Organization formats this part is ruled on. A format not listed has no ruling for it." })] })), part.sourceUrl && (_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: part.sourceUrl, tone: "muted", underline: "always", children: "Source" }), " · ", _jsx(TextLink, { href: String(ROUTES.PUBLIC.CREDITS), children: "Credits" })] }) })), _jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsx(Heading, { level: 2, size: "lg", children: usedBy.length > 0
-                                    ? `Used by ${usedBy.length} ${usedBy.length === 1 ? "model" : "models"}`
-                                    : "Used by" }), usedBy.length === 0 ? (_jsx(Text, { color: "muted", size: "sm", children: "No model in our database records this part yet." })) : (_jsx(Stack, { gap: "xs", className: "min-w-0", children: usedBy.map((m) => (_jsxs(Row, { gap: "sm", align: "center", padding: "inline", surface: "card", rounded: "md", border: "subtle", className: "min-w-0", children: [_jsxs(Div, { className: "flex-1 min-w-0", children: [m.categoryId ? (_jsx(TextLink, { href: hrefForModel(m.categoryId), children: m.name })) : (
-                                                /* 49 of 259 compositions did not join to a category.
-                                                   A link to a page that does not exist is worse than
-                                                   plain text, so the name renders unlinked. */
-                                                _jsx(Text, { color: "primary", children: m.name })), m.system && (_jsxs(Span, { size: "xs", color: "muted", children: [" ", "\u00B7 ", m.system] }))] }), m.productCode && (_jsx(Text, { size: "xs", color: "faint", className: "flex-shrink-0", children: m.productCode }))] }, m.id))) }))] }), exactListings.length > 0 && (_jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsxs(Heading, { level: 2, size: "lg", children: ["Buy this part", exactListingsTruncated && (_jsxs(Span, { size: "sm", color: "muted", children: [" ", "(", exactListings.length, "+)"] }))] }), _jsx(Stack, { gap: "xs", className: "min-w-0", children: exactListings.map((l) => (_jsxs(Div, { surface: "card", padding: "sm", rounded: "md", border: "subtle", 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))) })] })), _jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsxs(Row, { justify: "between", align: "center", wrap: true, gap: "sm", className: "min-w-0", children: [_jsxs(Heading, { level: 2, size: "lg", children: ["Listings", listingsTruncated && (_jsxs(Span, { size: "sm", color: "muted", children: [" ", "(", listings.length, "+)"] }))] }), listings.length > 0 && (_jsx(TextLink, { href: allListingsHref, children: "See all listings \u2192" }))] }), listings.length === 0 ? (_jsxs(Stack, { gap: "xs", className: "min-w-0", children: [_jsx(Text, { color: "muted", size: "sm", children: "Nobody is selling this part right now." }), _jsx(TextLink, { href: allListingsHref, children: "Search the catalogue \u2192" })] })) : (_jsx(Stack, { gap: "xs", className: "min-w-0", children: listings.map((l) => (_jsxs(Div, { surface: "card", padding: "sm", rounded: "md", border: "subtle", 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))) }))] }), part.source && (_jsxs(Text, { size: "xs", color: "faint", children: ["Source: ", part.source] }))] }) }) }));
-}

package/dist/features/parts/components/PartsIndexPageView.d.ts

@@ -1,42 +0,0 @@
-/**
- * D12 — the Beyblade parts gallery index, and one classification's listing.
- *
- * ── 🛑 THE INDEX COSTS ZERO FIRESTORE READS ────────────────────────────────
- *
- * The 20 classifications come from `ALL_PART_SLOTS` + `PART_SLOT_LABEL`, both
- * compile-checked, so the index is static. The tempting alternative — showing
- * a count per classification — is one query per slot, or a 753-document scan,
- * on a page that exists only to route. Rule #6 budgets ~3 round trips for a
- * whole render; 20 is not a rounding error.
- *
- * A count would also be the thing most likely to be wrong later: it is a
- * denormalised mirror of a collection the seed rewrites (Root Cause #42), and
- * the honest version of "we don't know how many" is to not say a number.
- *
- * The classification page below DOES read — one equality, bounded at 120,
- * which clears the largest real bucket (87 attack rings, measured).
- */
-import React from "react";
-import { type PartGlossaryDocument, type PartSlot } from "../schemas/firestore";
-export interface PartsIndexPageViewProps {
-    hrefForClassification: (slot: string) => string;
-    /**
-     * The search box, as a SLOT.
-     *
-     * 🛑 Not rendered directly, because this view is a Server Component and
-     * the box is a Client Component that fetches. Keeping it a slot also keeps
-     * the page's "ZERO Firestore reads" property literally true — the box
-     * reads a CDN object, never Firestore, and the index page stays static.
-     */
-    renderSearch?: () => React.ReactNode;
-}
-export declare function PartsIndexPageView({ hrefForClassification, renderSearch, }: PartsIndexPageViewProps): React.JSX.Element;
-export interface PartClassificationPageViewProps {
-    slot: PartSlot;
-    parts: readonly PartGlossaryDocument[];
-    /** The bounded fetch saturated, so the count renders as a floor. */
-    truncated?: boolean;
-    hrefForPart: (slot: string, tail: string) => string;
-    partsIndexHref: string;
-}
-export declare function PartClassificationPageView({ slot, parts, truncated, hrefForPart, partsIndexHref, }: PartClassificationPageViewProps): React.JSX.Element;

package/dist/features/parts/components/PartsIndexPageView.js

@@ -1,29 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Section } from "../../../ui/components/Semantic.js";
-import { Container, Stack, Row, Grid } from "../../../ui/components/Layout.js";
-import { Div } from "../../../ui/components/Div.js";
-import { Heading, Text, Span } from "../../../ui/components/Typography.js";
-import { TextLink } from "../../../ui/components/TextLink.js";
-import { Badge } from "../../../ui/components/Badge.js";
-import { ALL_PART_SLOTS, PART_SLOT_LABEL, } from "../schemas/firestore.js";
-/*
- * 🛑 Rendered as JSX from a Server Component, which is the normal RSC
- * boundary and is fine — the trap Root Cause #76 describes is CALLING a
- * `/client` runtime value or reading a property off it, not rendering a
- * client component. The toolbar needs the session, so it owns that itself.
- */
-import { RecordOwnerQuickActions } from "../../admin/components/RecordOwnerQuickActions.js";
-export function PartsIndexPageView({ hrefForClassification, renderSearch, }) {
-    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", children: [_jsx(Heading, { level: 1, children: "Beyblade parts gallery" }), _jsxs(Text, { color: "muted", children: ["Every component we have a record of, by what it is. A code like", " ", _jsx(Span, { weight: "semibold", children: "RF" }), " or ", _jsx(Span, { weight: "semibold", children: "105" }), " means different things in different generations, so parts are grouped by their classification rather than by code."] })] }), renderSearch?.(), _jsx(Grid, { cols: "navTiles", gap: "sm", className: "min-w-0", children: ALL_PART_SLOTS.map((slot) => (_jsx(Div, { surface: "card", padding: "sm", rounded: "md", border: "subtle", className: "min-w-0", children: _jsx(TextLink, { href: hrefForClassification(slot), children: PART_SLOT_LABEL[slot] }) }, slot))) })] }) }) }));
-}
-/** `performance-tip--rf` → `rf`. The id's tail IS the URL segment. */
-function tailOf(partId) {
-    const i = partId.indexOf("--");
-    return i >= 0 ? partId.slice(i + 2) : partId;
-}
-export function PartClassificationPageView({ slot, parts, truncated, hrefForPart, partsIndexHref, }) {
-    const label = PART_SLOT_LABEL[slot] ?? slot;
-    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", children: [_jsx(Text, { size: "sm", color: "muted", children: _jsx(TextLink, { href: partsIndexHref, children: "Parts" }) }), _jsx(Heading, { level: 1, children: label }), _jsx(Text, { color: "muted", size: "sm", children: parts.length === 0
-                                    ? "No parts recorded in this classification yet."
-                                    : `${parts.length}${truncated ? "+" : ""} recorded.` })] }), parts.length > 0 && (_jsx(Stack, { gap: "xs", className: "min-w-0", children: parts.map((p) => (_jsxs(Row, { gap: "sm", align: "center", padding: "inline", surface: "card", rounded: "md", border: "subtle", className: "min-w-0", children: [_jsxs(Div, { className: "flex-1 min-w-0", children: [_jsx(TextLink, { href: hrefForPart(p.slot, tailOf(p.id)), children: p.name }), typeof p.weightG === "number" && (_jsxs(Span, { size: "xs", color: "muted", children: [" ", "\u00B7 ", p.weightG, " g"] }))] }), p.code && (_jsx(Badge, { variant: "info", className: "flex-shrink-0", children: p.code })), _jsx(RecordOwnerQuickActions, { resource: "PART", recordId: p.id, placement: "detail", recordLabel: p.name })] }, p.id))) }))] }) }) }));
-}

package/dist/features/parts/components/PartsSearchBox.d.ts

@@ -1,9 +0,0 @@
-import React from "react";
-export interface PartsSearchBoxProps {
-    /** `siteSettings.search?.indexEnabled`. Read as `!== false`. */
-    indexEnabled?: boolean;
-    placeholder?: string;
-    /** Rows shown. A part search is a lookup, not a browse. */
-    limit?: number;
-}
-export declare function PartsSearchBox({ indexEnabled, placeholder, limit, }: PartsSearchBoxProps): React.JSX.Element;

package/dist/features/parts/components/PartsSearchBox.js

@@ -1,136 +0,0 @@
-"use client";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/*
- * WHY: 752 parts were reachable only by drilling classification -> code.
- *      `/parts` had no search input anywhere.
- * WHAT: A search box over the `part` slice of the local index. Zero Firestore
- *       reads, and it resolves the code ambiguity in the result row.
- *
- * ## 🛑 The ambiguity is the feature, not a problem to hide
- *
- * `route-map.ts` explains why a code alone cannot be a URL: "`105` is a Metal
- * Fight spin-track height, a bare number in Burst is a disc, and `1-60` is a
- * Beyblade X ratchet." So the honest answer to "105" is THREE results, each
- * naming its classification and each linking to the right two-segment path —
- * not one result picked by whatever sorted first.
- *
- * That is exactly what the index already carries: the part source puts the
- * classification in `detail` for precisely this reason, and derives the slug
- * by splitting the `${slot}--${code}` document id, which is the one
- * derivation guaranteed to agree with the page that exists.
- *
- * ## It does not replace the drill-down
- *
- * The classification grid stays. Browsing by "what kind of thing is this" is
- * a different question from "where is the part I can already name", and the
- * grid is the only one of the two that works when you do not know the word.
- *
- * @tag domain:parts
- * @tag layer:feature
- * @tag pattern:none
- * @tag access:client
- * @tag consumers:app/[locale]/parts/page.tsx
- * @tag sideEffects:network
- */
-import React from "react";
-import { Div } from "../../../ui/components/Div.js";
-import { Input } from "../../../ui/components/Input.js";
-import { Stack } from "../../../ui/components/Layout.js";
-import { Text } from "../../../ui/components/Typography.js";
-import { TextLink } from "../../../ui/components/TextLink.js";
-import { useSiteSearch } from "../../search/hooks/useSiteSearch.js";
-import { useUrlTable } from "../../../react/hooks/useUrlTable.js";
-import { TABLE_KEYS } from "../../../constants/table-keys.js";
-/** Only this slice of the index. See `resolveEntity`'s `types` parameter. */
-const PART_TYPES = ["part"];
-/** Stable identity — a `useMemo` dependency inside the hook. */
-const partLabel = () => "Parts";
-export function PartsSearchBox({ indexEnabled, placeholder = "Search parts by name or code — RF, 105, Rubber Flat…", limit = 10, }) {
-    /*
-     * ── 🛑 THE QUERY LIVES IN THE URL, SO A SEARCH IS SHAREABLE ──────────────
-     *
-     * This was `React.useState("")`, which meant typing filtered the list and
-     * left the address bar on `/parts`. Every detail page here is a real slug
-     * (`/parts/{classification}/{code}`, `/beys/{slug}`) and every other listing
-     * surface puts its state in the URL — `/search?q=…` reads `searchParams`
-     * server-side, and the category pages go as far as path segments
-     * (`/categories/{slug}/{tab}/sort/{sortKey}/page/{page}`). A client-local
-     * box was the one surface where you could not send someone what you were
-     * looking at.
-     *
-     * `useUrlTable` is the mechanism, not a second one invented here: it owns
-     * `router.replace()`, uses replace rather than push so typing does not fill
-     * the back button, and `TABLE_KEYS.QUERY` is the same `q` the rest of the
-     * app reads.
-     *
-     * 🛑 TWO pieces of state, deliberately, and they are not redundant. `draft`
-     * drives the input so a keystroke is never waiting on a navigation; the URL
-     * is the shareable record, written on a debounce. Driving the input straight
-     * from `searchParams` makes every character a round trip through the router
-     * and the field feels broken on a slow render.
-     *
-     * 🛑 `useSearchParams` requires a `<Suspense>` ancestor or the build fails
-     * on prerender (Root Cause #17b). The root locale layout has one, which is
-     * what the ~246 comments citing that pattern are about.
-     */
-    /*
-     * 🛑 DESTRUCTURED, because `useUrlTable` returns a fresh object literal every
-     * render while the callbacks inside it are `useCallback`-memoised. Depending
-     * on `table` would make the effect below re-run on every render; depending on
-     * `set`/`clear` is stable. Same trap as the `loadOptions` identity bug in
-     * `PaginatedSelect`, where an unstable function re-triggered a fetch effect.
-     */
-    const { get, set, clear } = useUrlTable();
-    const urlQuery = get(TABLE_KEYS.QUERY) ?? "";
-    const [draft, setDraft] = React.useState(urlQuery);
-    /*
-     * 🛑 SEEDED FROM THE URL, not `false`.
-     *
-     * `useSiteSearch` only fetches the index when `active`, which previously
-     * meant "the user has focused the box". Arriving on `/parts?q=rubber-flat`
-     * from a shared link, `active` would be false — so the query would sit in
-     * the field and in the address bar having searched NOTHING until the visitor
-     * clicked into the input. That defeats the entire reason for putting the
-     * query in the URL, and it is the kind of gap that looks like the link
-     * "didn't work" rather than like a missing fetch.
-     */
-    const [active, setActive] = React.useState(urlQuery.length > 0);
-    /*
-     * Back/forward and a shared link both change the URL without touching the
-     * input, so the draft follows the URL when the URL moves on its own.
-     * Guarded on inequality — without that this fights the user's typing.
-     */
-    React.useEffect(() => {
-        setDraft((prev) => (prev === urlQuery ? prev : urlQuery));
-    }, [urlQuery]);
-    /*
-     * 🛑 Debounced, because `router.replace` on every keystroke is a navigation
-     * per character. 300ms is the same order the rest of the app uses for a
-     * search field, and the cleanup makes the last keystroke the one that wins.
-     */
-    React.useEffect(() => {
-        if (draft === urlQuery)
-            return;
-        const t = setTimeout(() => {
-            if (draft)
-                set(TABLE_KEYS.QUERY, draft);
-            else
-                clear([TABLE_KEYS.QUERY]);
-        }, 300);
-        return () => clearTimeout(t);
-    }, [draft, urlQuery, set, clear]);
-    /* The index is searched on the URL's value — the thing that is shareable. */
-    const query = urlQuery;
-    const { status, result } = useSiteSearch(query, {
-        active,
-        indexEnabled,
-        types: PART_TYPES,
-        label: partLabel,
-    });
-    const hits = result?.groups[0]?.hits ?? [];
-    const typed = query.trim().length > 0;
-    return (_jsxs(Stack, { gap: "sm", className: "min-w-0", children: [_jsx(Input, { type: "search", value: draft, placeholder: placeholder, "aria-label": "Search parts", onFocus: () => setActive(true), onChange: (event) => {
-                    setActive(true);
-                    setDraft(event.target.value);
-                } }), typed && status === "loading" && _jsx(Text, { color: "muted", children: "Searching\u2026" }), typed && (status === "failed" || status === "disabled") && (_jsx(Text, { size: "sm", color: "muted", children: "Part search is unavailable right now \u2014 browse by classification below." })), typed && status === "ready" && hits.length === 0 && (_jsx(Text, { color: "muted", children: "No part matches that name or code." })), hits.length > 0 && (_jsx(Stack, { gap: "xs", className: "min-w-0", children: hits.slice(0, limit).map((hit) => (_jsxs(Div, { surface: "card", padding: "sm", rounded: "md", border: "subtle", children: [_jsx(TextLink, { href: hit.href, children: hit.title }), hit.detail && (_jsx(Text, { size: "xs", color: "muted", children: hit.detail }))] }, hit.id))) }))] }));
-}

package/dist/features/parts/schemas/admin-edit.d.ts

@@ -1,81 +0,0 @@
-/**
- * Field-level protection for hand-corrections to GENERATED reference data.
- *
- * ── 🛑 THE PROBLEM THIS SOLVES ────────────────────────────────────────────
- *
- * `partGlossary` (2,488 rows) and `beys` (1,988) are produced by committed
- * generators from a crawled corpus, and `appkit-seed load` writes them with
- * `set(doc, { merge: true })`. A merge-write overwrites every key present in
- * the payload — so an admin who corrects a wrong extracted weight loses that
- * correction on the next reseed, silently, and the row goes back to being
- * wrong while `appkit-seed status` reports the collection perfectly in sync
- * (it counts ids, and the id did not change).
- *
- * That is not hypothetical for this dataset. This session alone found five
- * wrong claims in the source corpus — an inverted tip transition, a mode that
- * was actually launch spin direction, a mechanism on the wrong part, a part
- * with no modes at all, and a part named "Duo:Dual" that is Delta Drive. A
- * hand-correction is the fast path for exactly those, and it has to survive.
- *
- * ── 🛑 FIELD-LEVEL, NOT ROW-LEVEL ────────────────────────────────────────
- *
- * The obvious shape is one boolean meaning "do not touch this row". It is
- * wrong: freezing a whole row because somebody fixed one weight means the row
- * stops receiving every genuine improvement the generator makes afterwards —
- * a better description, a newly resolved part id, a corrected release date.
- * The row quietly falls out of the dataset's own maintenance.
- *
- * So `adminEditedFields` names the keys a human owns. The loader strips
- * exactly those from its payload and writes everything else, which means a
- * corrected weight and an improved description can both be true at once.
- *
- * `adminEdited` is a plain boolean beside it purely so the loader can find
- * these rows with ONE equality query per collection instead of reading all
- * 4,476 documents to discover the handful that matter. `array-contains` on
- * `adminEditedFields` cannot answer "has any value", and an `orderBy` or `!=`
- * on it would silently exclude every row that lacks the field — which is all
- * of them (Root Cause #100).
- *
- * 🛑 KEEP THE TWO IN SYNC. `adminEdited` is `adminEditedFields.length > 0`.
- * Writing one without the other either hides a protected row from the loader
- * (so the edit is lost anyway) or makes the loader fetch a row with nothing to
- * protect. `applyAdminEdit` is the only function that should set either.
- */
-/** The fields a human has taken ownership of on one generated row. */
-export interface AdminEditableRecord {
-    /**
-     * `true` iff `adminEditedFields` is non-empty. Exists ONLY so the seed
-     * loader can find protected rows with one indexed equality.
-     */
-    adminEdited?: boolean;
-    /**
-     * Keys the generator must not overwrite. Dot paths are NOT supported — a
-     * nested object is owned whole, because a merge-write replaces a map wholesale
-     * and protecting one leaf of it is not something `{ merge: true }` can express.
-     */
-    adminEditedFields?: string[];
-    /** When the most recent hand-edit landed. Audit trail, never read by logic. */
-    adminEditedAt?: Date;
-    /** Who. The Auth UID, never a name — this travels into no public projection. */
-    adminEditedBy?: string;
-}
-/**
- * Merge a hand-edit into a record, keeping the two protection fields honest.
- *
- * Returns the patch to write — the caller's changed fields plus the updated
- * ownership set. 🛑 Ownership is CUMULATIVE: editing the weight today and the
- * description tomorrow must leave both protected, so the existing set is
- * unioned rather than replaced.
- */
-export declare function applyAdminEdit<TChanges extends object>(existing: Pick<AdminEditableRecord, "adminEditedFields"> | null | undefined, changes: TChanges, actorUid: string): TChanges & Required<Pick<AdminEditableRecord, "adminEdited" | "adminEditedFields">> & {
-    adminEditedAt: Date;
-    adminEditedBy: string;
-};
-/**
- * Strip the fields a human owns out of a generator payload.
- *
- * Used by `appkit/scripts/seed-cli.mjs`. Exported from here rather than
- * duplicated there so the rule has one definition — the CLI is `.mjs` and
- * reads this through the built package, the same way it reads the seed data.
- */
-export declare function stripAdminOwnedFields<T extends object>(payload: T, ownedFields: readonly string[] | undefined): Partial<T>;

package/dist/features/parts/schemas/admin-edit.js

@@ -1,89 +0,0 @@
-/**
- * Field-level protection for hand-corrections to GENERATED reference data.
- *
- * ── 🛑 THE PROBLEM THIS SOLVES ────────────────────────────────────────────
- *
- * `partGlossary` (2,488 rows) and `beys` (1,988) are produced by committed
- * generators from a crawled corpus, and `appkit-seed load` writes them with
- * `set(doc, { merge: true })`. A merge-write overwrites every key present in
- * the payload — so an admin who corrects a wrong extracted weight loses that
- * correction on the next reseed, silently, and the row goes back to being
- * wrong while `appkit-seed status` reports the collection perfectly in sync
- * (it counts ids, and the id did not change).
- *
- * That is not hypothetical for this dataset. This session alone found five
- * wrong claims in the source corpus — an inverted tip transition, a mode that
- * was actually launch spin direction, a mechanism on the wrong part, a part
- * with no modes at all, and a part named "Duo:Dual" that is Delta Drive. A
- * hand-correction is the fast path for exactly those, and it has to survive.
- *
- * ── 🛑 FIELD-LEVEL, NOT ROW-LEVEL ────────────────────────────────────────
- *
- * The obvious shape is one boolean meaning "do not touch this row". It is
- * wrong: freezing a whole row because somebody fixed one weight means the row
- * stops receiving every genuine improvement the generator makes afterwards —
- * a better description, a newly resolved part id, a corrected release date.
- * The row quietly falls out of the dataset's own maintenance.
- *
- * So `adminEditedFields` names the keys a human owns. The loader strips
- * exactly those from its payload and writes everything else, which means a
- * corrected weight and an improved description can both be true at once.
- *
- * `adminEdited` is a plain boolean beside it purely so the loader can find
- * these rows with ONE equality query per collection instead of reading all
- * 4,476 documents to discover the handful that matter. `array-contains` on
- * `adminEditedFields` cannot answer "has any value", and an `orderBy` or `!=`
- * on it would silently exclude every row that lacks the field — which is all
- * of them (Root Cause #100).
- *
- * 🛑 KEEP THE TWO IN SYNC. `adminEdited` is `adminEditedFields.length > 0`.
- * Writing one without the other either hides a protected row from the loader
- * (so the edit is lost anyway) or makes the loader fetch a row with nothing to
- * protect. `applyAdminEdit` is the only function that should set either.
- */
-/**
- * Merge a hand-edit into a record, keeping the two protection fields honest.
- *
- * Returns the patch to write — the caller's changed fields plus the updated
- * ownership set. 🛑 Ownership is CUMULATIVE: editing the weight today and the
- * description tomorrow must leave both protected, so the existing set is
- * unioned rather than replaced.
- */
-export function applyAdminEdit(existing, changes, actorUid) {
-    const owned = new Set(existing?.adminEditedFields ?? []);
-    for (const key of Object.keys(changes)) {
-        /*
-         * The protection fields themselves are never protected — that would make
-         * the set unmodifiable by the next edit.
-         */
-        if (key.startsWith("adminEdited"))
-            continue;
-        owned.add(key);
-    }
-    const fields = [...owned].sort();
-    return {
-        ...changes,
-        adminEditedFields: fields,
-        adminEdited: fields.length > 0,
-        adminEditedAt: new Date(),
-        adminEditedBy: actorUid,
-    };
-}
-/**
- * Strip the fields a human owns out of a generator payload.
- *
- * Used by `appkit/scripts/seed-cli.mjs`. Exported from here rather than
- * duplicated there so the rule has one definition — the CLI is `.mjs` and
- * reads this through the built package, the same way it reads the seed data.
- */
-export function stripAdminOwnedFields(payload, ownedFields) {
-    if (!ownedFields?.length)
-        return payload;
-    const out = {};
-    for (const [k, v] of Object.entries(payload)) {
-        if (ownedFields.includes(k))
-            continue;
-        out[k] = v;
-    }
-    return out;
-}