@mohasinac/appkit 4.30.18 → 4.31.0

package/dist/features/search/action-index/derive.js

@@ -0,0 +1,121 @@
+/*
+ * WHY: An index of "everything a user can do" is worth having exactly once and
+ *      worth maintaining never. Hand-writing 260 entries beside the nav arrays
+ *      they duplicate produces the drift this plan has spent every wave
+ *      undoing — ten hand-written enumerations of one union (Root Cause #61),
+ *      three option arrays that had each silently lost a value (W3c), fifteen
+ *      postal rules (W5).
+ * WHAT: Derive the static base FROM the nav groups and the quick-action
+ *       registry, so an entry cannot exist without its nav item and cannot
+ *       go stale when one is renamed.
+ *
+ * W6 is what makes this possible: every nav item now carries a `description`,
+ * `keywords` and a derived `id`. Before that there was nothing to derive
+ * from — which is the actual reason `Search.tsx`'s finished `quickLinks` path
+ * was never wired to anything.
+ *
+ * EXPORTS: deriveNavEntries, deriveQuickActionEntries, buildActionIndexBase
+ *
+ * @tag domain:search
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:action-index route,CommandPalette
+ * @tag sideEffects:none
+ */
+/**
+ * Every sidebar entry, as an index entry.
+ *
+ * `sectionPath` is the breadcrumb a result row shows — "Admin › System › Site
+ * Settings" — and it is the reason the group title is worth carrying: two
+ * portals both have "Orders", and without the path a result list shows the
+ * same word twice with no way to tell which one you want.
+ */
+export function deriveNavEntries(sources) {
+    const entries = [];
+    for (const { portal, portalLabel, groups } of sources) {
+        for (const group of groups) {
+            for (const item of group.items) {
+                entries.push({
+                    /*
+                     * The nav item's own derived id, reused rather than re-derived. It
+                     * is already `nav-{portal}-{slug}`, so prefixing the kind keeps the
+                     * index's `{portal}:{kind}:{slug}` convention without inventing a
+                     * second identity for the same thing.
+                     */
+                    id: item.id ?? `${portal}:nav:${item.href}`,
+                    kind: "nav",
+                    portal,
+                    label: item.label,
+                    description: item.description,
+                    keywords: item.keywords,
+                    href: item.href,
+                    sectionPath: `${portalLabel} › ${group.title}`,
+                    ...(item.requiredPermission
+                        ? { requiredPermission: item.requiredPermission }
+                        : {}),
+                });
+            }
+        }
+    }
+    return entries;
+}
+/**
+ * Quick actions, as index entries.
+ *
+ * 🛑 An action with no resolvable href is DROPPED, not indexed with a blank
+ * one. `DASHBOARD_QUICK_ACTION_META`'s `routeKey` is dead — every page
+ * re-declares its own `*_QUICK_ACTION_HREFS` map instead — so a registry entry
+ * may genuinely have nowhere to go. Indexing it anyway produces a search
+ * result that does nothing when clicked, which is worse than not finding it.
+ */
+export function deriveQuickActionEntries(actions, portal, portalLabel, hrefFor) {
+    const entries = [];
+    for (const action of actions) {
+        const href = action.href ?? hrefFor(action);
+        if (!href)
+            continue;
+        entries.push({
+            id: `${portal}:action:${action.id}`,
+            kind: "action",
+            portal,
+            label: action.label,
+            description: action.description,
+            keywords: action.keywords,
+            href,
+            sectionPath: `${portalLabel} › Quick actions`,
+            ...(action.iconKey ? { iconName: action.iconKey } : {}),
+            ...(action.requiredPermission
+                ? { requiredPermission: action.requiredPermission }
+                : {}),
+            ...(action.requiredRole ? { requiredRole: action.requiredRole } : {}),
+            /*
+             * A quick action is a shortcut to something already reachable from the
+             * nav, so it ranks BELOW the nav entry for the same screen. Searching
+             * "orders" should land on Orders, not on "Create an order".
+             */
+            weight: -10,
+        });
+    }
+    return entries;
+}
+/**
+ * Assemble the static base.
+ *
+ * Deduplicated by id, first writer winning, so a quick action that shares an
+ * id with a nav entry does not produce two rows for one destination — and the
+ * nav entry, being passed first, is the one that survives.
+ */
+export function buildActionIndexBase(...groups) {
+    const seen = new Set();
+    const out = [];
+    for (const list of groups) {
+        for (const entry of list) {
+            if (seen.has(entry.id))
+                continue;
+            seen.add(entry.id);
+            out.push(entry);
+        }
+    }
+    return out;
+}

package/dist/features/search/action-index/repository.d.ts

@@ -0,0 +1,42 @@
+import { BaseRepository } from "../../../providers/db-firebase";
+import { type ActionIndexControl, type ActionIndexEntry, type ActionIndexOverride } from "./types";
+/** The stored document. `id` is always `ACTION_INDEX_DOC_ID`. */
+export interface ActionIndexDocument extends ActionIndexControl {
+    id: string;
+    updatedAt?: Date;
+    updatedBy?: string;
+}
+export declare class ActionIndexRepository extends BaseRepository<ActionIndexDocument> {
+    constructor();
+    /**
+     * The control document, or an empty one.
+     *
+     * 🛑 Returns EMPTY rather than null, and that is load-bearing:
+     * `mergeActionIndex` treats a missing control as "no overrides", so a site
+     * that has never opened the admin screen still gets the full static base.
+     * A null here would make every caller write the same `?? EMPTY` and one of
+     * them would forget, blanking the search.
+     */
+    getControl(): Promise<ActionIndexControl>;
+    /**
+     * Overwrite one entry's override.
+     *
+     * Merged into the stored map rather than replacing it, because the admin
+     * screen edits one row at a time and a whole-map write would drop every
+     * other override made in a different browser tab — the lost-update shape
+     * that `mergeLotteryConfig` exists to prevent on the lottery side.
+     */
+    setOverride(entryId: string, override: ActionIndexOverride, actorUid: string): Promise<void>;
+    /** Drop an override, returning the entry to whatever the code says. */
+    clearOverride(entryId: string, actorUid: string): Promise<void>;
+    /**
+     * Replace the admin-authored entries.
+     *
+     * Whole-array, unlike `setOverride`: the custom list is edited as a list in
+     * one screen, and its ids are chosen by the admin rather than derived, so
+     * there is no stable key to merge on.
+     */
+    setCustomEntries(custom: ActionIndexEntry[], actorUid: string): Promise<void>;
+    private write;
+}
+export declare const actionIndexRepository: ActionIndexRepository;

package/dist/features/search/action-index/repository.js

@@ -0,0 +1,100 @@
+/*
+ * WHY: D7 — the action index is a Firestore CONTROL PLANE over a static TS
+ *      base, not a second copy of it. An admin can hide, rename, re-describe,
+ *      retag, reorder and author entries; the code keeps `kind`, `href` and
+ *      every permission field for built-ins, because renaming a toggle is
+ *      content and repointing a built-in route is routing.
+ * WHAT: The `actionIndex/global` singleton and its repository.
+ *
+ * ## Deliberately NOT folded into `siteSettings`
+ *
+ * That document is read by an unauthenticated, edge-cached route
+ * (`GET /api/site-settings`, `s-maxage=600`). This one is projected by role and
+ * must never be served from a shared cache — putting them together is one
+ * refactor away from publishing the admin site map, which is exactly the class
+ * of defect Root Cause #70 records.
+ *
+ * ## One document, ~85 KB
+ *
+ * ~380 entries at full size, comfortably inside Firestore's 1 MB ceiling, and
+ * one read rather than a query. The read path caches for 5 minutes and is
+ * fetched **once per session per portal** — a read per keystroke would exhaust
+ * the 50k/day free tier at roughly thirty sessions, and typeahead matching has
+ * to be sub-16ms anyway, which a network hop is not.
+ *
+ * EXPORTS: ActionIndexRepository, actionIndexRepository
+ *
+ * @tag domain:search
+ * @tag layer:repository
+ * @tag pattern:singleton-doc
+ * @tag access:server
+ * @tag consumers:/api/admin/action-index,/api/action-index
+ * @tag sideEffects:firestore
+ */
+import { BaseRepository } from "../../../providers/db-firebase";
+import { ACTION_INDEX_COLLECTION, ACTION_INDEX_DOC_ID, } from "./types";
+/** What an empty control plane looks like — no overrides, no custom entries. */
+const EMPTY_CONTROL = { entries: {}, custom: [] };
+export class ActionIndexRepository extends BaseRepository {
+    constructor() {
+        super(ACTION_INDEX_COLLECTION);
+    }
+    /**
+     * The control document, or an empty one.
+     *
+     * 🛑 Returns EMPTY rather than null, and that is load-bearing:
+     * `mergeActionIndex` treats a missing control as "no overrides", so a site
+     * that has never opened the admin screen still gets the full static base.
+     * A null here would make every caller write the same `?? EMPTY` and one of
+     * them would forget, blanking the search.
+     */
+    async getControl() {
+        const doc = await this.findById(ACTION_INDEX_DOC_ID);
+        if (!doc)
+            return EMPTY_CONTROL;
+        return { entries: doc.entries ?? {}, custom: doc.custom ?? [] };
+    }
+    /**
+     * Overwrite one entry's override.
+     *
+     * Merged into the stored map rather than replacing it, because the admin
+     * screen edits one row at a time and a whole-map write would drop every
+     * other override made in a different browser tab — the lost-update shape
+     * that `mergeLotteryConfig` exists to prevent on the lottery side.
+     */
+    async setOverride(entryId, override, actorUid) {
+        const control = await this.getControl();
+        const next = {
+            ...control,
+            entries: { ...control.entries, [entryId]: override },
+        };
+        await this.write(next, actorUid);
+    }
+    /** Drop an override, returning the entry to whatever the code says. */
+    async clearOverride(entryId, actorUid) {
+        const control = await this.getControl();
+        const entries = { ...control.entries };
+        delete entries[entryId];
+        await this.write({ ...control, entries }, actorUid);
+    }
+    /**
+     * Replace the admin-authored entries.
+     *
+     * Whole-array, unlike `setOverride`: the custom list is edited as a list in
+     * one screen, and its ids are chosen by the admin rather than derived, so
+     * there is no stable key to merge on.
+     */
+    async setCustomEntries(custom, actorUid) {
+        const control = await this.getControl();
+        await this.write({ ...control, custom }, actorUid);
+    }
+    async write(control, actorUid) {
+        const payload = { ...control, updatedAt: new Date(), updatedBy: actorUid };
+        const existing = await this.findById(ACTION_INDEX_DOC_ID);
+        if (existing)
+            await this.update(ACTION_INDEX_DOC_ID, payload);
+        else
+            await this.createWithId(ACTION_INDEX_DOC_ID, payload);
+    }
+}
+export const actionIndexRepository = new ActionIndexRepository();

package/dist/features/search/action-index/settings-entries.d.ts

@@ -0,0 +1,41 @@
+import type { SiteSettingsTabId } from "../../admin/constants/site-settings-tabs";
+import type { ActionIndexEntry } from "./types";
+/** One control on the site-settings screen. */
+export interface SettingsIndexSource {
+    /** Slug — becomes both the entry id and the `#anchor`. */
+    slug: string;
+    label: string;
+    description: string;
+    keywords: string[];
+    tab: SiteSettingsTabId;
+    /** `toggle` for an on/off switch, `setting` for a value. */
+    kind: "toggle" | "setting";
+    /**
+     * Whether the view renders `id="setting-{slug}"` for this control.
+     *
+     * 🛑 Opt-in, and audited. An anchor that matches no `id=` in the DOM scrolls
+     * nowhere and reads as the search having missed — so claiming one you have
+     * not added is worse than not claiming it. An entry without one deep-links
+     * to its TAB, which is truthful: "this lives on the Fees tab" is a smaller
+     * promise than "here is the control", and it is one the page can keep.
+     */
+    anchored?: boolean;
+}
+/**
+ * The controls worth finding.
+ *
+ * Deliberately not all ~160: a search result list is only useful while it is
+ * short, and "Hero title" is not something anyone hunts for — they open the
+ * About tab and see it. What is here is what someone arrives ALREADY looking
+ * for, usually in a hurry, and usually not knowing which tab it is filed under.
+ */
+export declare const SITE_SETTINGS_ENTRIES: readonly SettingsIndexSource[];
+/**
+ * The settings entries, as index entries.
+ *
+ * `deepLink` carries the whole query-and-hash — `?tab=fees#setting-cod-enabled`
+ * — rather than just the tab, because landing on the right tab and leaving the
+ * reader to find the control among forty others is most of the way to not
+ * having searched at all.
+ */
+export declare function deriveSettingsEntries(settingsHref: string, requiredPermission?: string): ActionIndexEntry[];

package/dist/features/search/action-index/settings-entries.js

@@ -0,0 +1,268 @@
+/*
+ * WHY: "It should be searchable — if I search for the maintenance toggle it
+ *      should find it." A nav-only index cannot: the maintenance toggle is
+ *      not a page, it is a control on tab ⓵ of an 1800-line settings screen,
+ *      and the only thing naming it is a `<Toggle label="Maintenance mode">`
+ *      inside that screen's JSX.
+ * WHAT: Track B — the declarative map of settings and toggles, each with the
+ *       `?tab=`/`#anchor` that reaches the control itself.
+ *
+ * ## Why this is declared rather than derived
+ *
+ * Track A (`FieldUiMeta.index`) covers every schema-driven form for free. It
+ * yields **nothing** here, because `AdminSiteSettingsView` is not schema-driven
+ * — it is ~160 controls bound to individual `useState` calls, and it is on
+ * W8's tabbing list precisely because of that. Waiting for the derivation
+ * would mean the headline request — find the maintenance toggle — ships last.
+ *
+ * So this is a hand-written map, and it is the ONE in this plan that is
+ * defensible: there is no existing array it duplicates. `audit-nav-metadata`'s
+ * sibling check keeps its `tab` values inside `SiteSettingsTabId`, so the half
+ * that CAN drift is the half that is guarded.
+ *
+ * ## An anchor is CLAIMED, not assumed
+ *
+ * A deep link to `#setting-maintenance-mode` that matches no `id=` in the DOM
+ * scrolls nowhere and reads as the search having missed — so an entry opts in
+ * with `anchored: true`, and `audit-action-index` checks that the id exists.
+ * Everything else deep-links to its TAB, which is a smaller promise ("this
+ * lives on the Fees tab") and one the page can keep.
+ *
+ * The first run of that audit reported thirteen dead anchors, because this
+ * file declared twenty-two entries while the view carried nine ids. That is
+ * the rule doing its job on the commit that introduced it.
+ *
+ * EXPORTS: SITE_SETTINGS_ENTRIES, deriveSettingsEntries
+ *
+ * @tag domain:search
+ * @tag layer:shared
+ * @tag pattern:registry
+ * @tag access:isomorphic
+ * @tag consumers:action index
+ * @tag sideEffects:none
+ */
+/**
+ * The controls worth finding.
+ *
+ * Deliberately not all ~160: a search result list is only useful while it is
+ * short, and "Hero title" is not something anyone hunts for — they open the
+ * About tab and see it. What is here is what someone arrives ALREADY looking
+ * for, usually in a hurry, and usually not knowing which tab it is filed under.
+ */
+export const SITE_SETTINGS_ENTRIES = [
+    {
+        slug: "maintenance-mode",
+        anchored: true,
+        label: "Maintenance mode",
+        description: "Take the site offline for visitors and show a message instead.",
+        keywords: ["offline", "down for maintenance", "close the site", "under construction"],
+        tab: "branding",
+        kind: "toggle",
+    },
+    {
+        slug: "maintenance-message",
+        label: "Maintenance message",
+        description: "What visitors see while the site is in maintenance mode.",
+        keywords: ["offline message", "downtime notice"],
+        tab: "branding",
+        kind: "setting",
+    },
+    {
+        slug: "announcement-bar",
+        anchored: true,
+        label: "Announcement bar",
+        description: "Show a message across the top of every page.",
+        keywords: ["banner", "notice", "top bar", "sale banner"],
+        tab: "announcement",
+        kind: "toggle",
+    },
+    {
+        slug: "robots-noindex",
+        anchored: true,
+        label: "Hide from search engines",
+        description: "Stop Google indexing the site. Use carefully — recovery is slow.",
+        keywords: ["noindex", "google", "seo", "deindex", "hide from google"],
+        tab: "seo",
+        kind: "toggle",
+    },
+    {
+        slug: "razorpay-enabled",
+        anchored: true,
+        label: "Online payments (Razorpay)",
+        description: "Accept cards and UPI through Razorpay. Off by default; manual payment is the default.",
+        keywords: ["card payments", "razorpay", "online payment", "gateway", "upi"],
+        tab: "fees",
+        kind: "toggle",
+    },
+    {
+        slug: "manual-payment-enabled",
+        anchored: true,
+        label: "Manual UPI / bank transfer",
+        description: "Let buyers pay by transfer and upload proof for review.",
+        keywords: ["upi", "bank transfer", "manual payment", "proof"],
+        tab: "fees",
+        kind: "toggle",
+    },
+    {
+        slug: "cod-enabled",
+        anchored: true,
+        label: "Cash on delivery",
+        description: "Let buyers pay when the parcel arrives.",
+        keywords: ["cod", "cash on delivery", "pay on delivery"],
+        tab: "fees",
+        kind: "toggle",
+    },
+    {
+        slug: "platform-commission",
+        label: "Platform commission",
+        description: "What the platform takes from each sale, and its cap.",
+        keywords: ["commission", "our cut", "platform fee", "take rate"],
+        tab: "fees",
+        kind: "setting",
+    },
+    {
+        slug: "google-analytics",
+        label: "Google Analytics",
+        description: "The GA4 measurement id used for site traffic.",
+        keywords: ["ga4", "analytics id", "tracking", "measurement id", "google"],
+        tab: "integrations",
+        kind: "setting",
+    },
+    {
+        slug: "facebook-pixel",
+        label: "Facebook Pixel",
+        description: "The Meta Pixel id used for ad attribution.",
+        keywords: ["meta pixel", "facebook", "ads tracking", "conversion"],
+        tab: "integrations",
+        kind: "setting",
+    },
+    {
+        slug: "free-shipping-threshold",
+        label: "Free shipping threshold",
+        description: "The order value above which delivery is free.",
+        keywords: ["free delivery", "shipping over", "minimum for free shipping"],
+        tab: "shipping",
+        kind: "setting",
+    },
+    {
+        slug: "bid-increment",
+        label: "Minimum bid increment",
+        description: "The smallest amount a new bid must beat the current one by.",
+        keywords: ["bidding step", "increment", "auction minimum"],
+        tab: "auction",
+        kind: "setting",
+    },
+    {
+        slug: "anti-sniping",
+        label: "Anti-sniping extension",
+        description: "Extend an auction when a bid lands in its final seconds.",
+        keywords: ["sniping", "last second bid", "extend auction", "going going gone"],
+        tab: "auction",
+        kind: "setting",
+    },
+    {
+        slug: "email-notifications",
+        anchored: true,
+        label: "Email notifications",
+        description: "Whether the platform sends email at all.",
+        keywords: ["email", "resend", "transactional email", "stop emails"],
+        tab: "notifications",
+        kind: "toggle",
+    },
+    {
+        slug: "whatsapp-notifications",
+        anchored: true,
+        label: "WhatsApp notifications",
+        description: "Send order updates over WhatsApp.",
+        keywords: ["whatsapp", "order updates", "meta"],
+        tab: "notifications",
+        kind: "toggle",
+    },
+    {
+        slug: "daily-digest",
+        anchored: true,
+        label: "Daily status digest",
+        description: "A once-a-day operations summary to the admin inbox.",
+        keywords: ["digest", "daily email", "summary", "ops report"],
+        tab: "notifications",
+        kind: "toggle",
+    },
+    {
+        slug: "emi-threshold",
+        label: "EMI eligibility threshold",
+        description: "The order value above which instalments are offered.",
+        keywords: ["instalments", "installments", "emi minimum", "pay monthly"],
+        tab: "emi",
+        kind: "setting",
+    },
+    {
+        slug: "gst-rates",
+        label: "GST rates and HSN defaults",
+        description: "The tax rates applied to listings, and the fallback HSN code.",
+        keywords: ["tax", "gst", "hsn", "vat"],
+        tab: "gst",
+        kind: "setting",
+    },
+    {
+        slug: "gstin",
+        label: "GSTIN and registered business",
+        description: "The registration number and legal address printed on invoices.",
+        keywords: ["gstin", "tax number", "registered address", "legal name"],
+        tab: "legal",
+        kind: "setting",
+    },
+    {
+        slug: "enabled-listing-types",
+        label: "Enabled listing types",
+        description: "Which kinds of listing sellers may create.",
+        keywords: ["auctions off", "disable pre-orders", "listing types", "turn off"],
+        tab: "listings",
+        kind: "toggle",
+    },
+    {
+        slug: "watermark",
+        label: "Photo watermark",
+        description: "The mark stamped onto uploaded product photos.",
+        keywords: ["watermark", "logo on photos", "protect images"],
+        tab: "watermark",
+        kind: "setting",
+    },
+    {
+        slug: "upload-limits",
+        label: "Upload and listing limits",
+        description: "Maximum file size, image count and per-account listing caps.",
+        keywords: ["max upload", "file size", "how many listings", "quota", "limit"],
+        tab: "limits",
+        kind: "setting",
+    },
+];
+/**
+ * The settings entries, as index entries.
+ *
+ * `deepLink` carries the whole query-and-hash — `?tab=fees#setting-cod-enabled`
+ * — rather than just the tab, because landing on the right tab and leaving the
+ * reader to find the control among forty others is most of the way to not
+ * having searched at all.
+ */
+export function deriveSettingsEntries(settingsHref, requiredPermission = "settings:read") {
+    return SITE_SETTINGS_ENTRIES.map((entry) => ({
+        id: `admin:${entry.kind}:${entry.slug}`,
+        kind: entry.kind,
+        portal: "admin",
+        label: entry.label,
+        description: entry.description,
+        keywords: entry.keywords,
+        href: settingsHref,
+        deepLink: entry.anchored
+            ? `?tab=${entry.tab}#setting-${entry.slug}`
+            : `?tab=${entry.tab}`,
+        sectionPath: "Admin › System › Site Settings",
+        requiredPermission,
+        /*
+         * Above nav entries. Someone searching "maintenance" wants the toggle, not
+         * the settings page it lives on — and the page will also match, on its own
+         * description, so without this the container outranks the thing.
+         */
+        weight: 20,
+    }));
+}

package/dist/features/search/action-index/types.d.ts

@@ -0,0 +1,81 @@
+import type { NavPortal } from "../../../_internal/shared/features/layout/types";
+/**
+ * What kind of thing an entry is.
+ *
+ * The distinction that matters is `nav`/`page` (somewhere you go) versus
+ * `setting`/`toggle`/`action` (something you change or do) — a search for
+ * "maintenance mode" wants the toggle, not the settings page it lives on, and
+ * only the kind tells them apart.
+ */
+export type ActionIndexKind = "nav" | "page" | "section" | "setting" | "toggle" | "action";
+export interface ActionIndexEntry {
+    /** `{portal}:{kind}:{slug}` — also the overlay's React key. */
+    id: string;
+    kind: ActionIndexKind;
+    /** `public` for anything outside the three dashboards. */
+    portal: NavPortal | "public";
+    label: string;
+    description?: string;
+    keywords?: string[];
+    href: string;
+    /**
+     * The `?tab=`/`#anchor` that reaches the exact control, when the href alone
+     * only reaches the page it lives on. This is what makes a search for
+     * "maintenance" land on the toggle rather than on Site Settings.
+     */
+    deepLink?: string;
+    /** Breadcrumb for the result row — "Admin › System › Site Settings". */
+    sectionPath?: string;
+    requiredRole?: string;
+    requiredPermission?: string;
+    requiresTester?: boolean;
+    /** A lucide icon NAME. See the header for why this is not a component. */
+    iconName?: string;
+    /** Higher sorts first among equal-scoring matches. Default 0. */
+    weight?: number;
+}
+/** What an admin may change about a built-in entry. */
+export interface ActionIndexOverride {
+    enabled?: boolean;
+    label?: string;
+    description?: string;
+    keywords?: string[];
+    weight?: number;
+    group?: string;
+    order?: number;
+}
+/**
+ * The stored control document, `actionIndex/global`.
+ *
+ * Deliberately NOT folded into `siteSettings`: that document is read publicly
+ * and edge-cached, and this one is projected by role.
+ */
+export interface ActionIndexControl {
+    entries: Record<string, ActionIndexOverride>;
+    /** Admin-authored entries, appended after the static base. */
+    custom: ActionIndexEntry[];
+}
+export declare const ACTION_INDEX_COLLECTION: "actionIndex";
+export declare const ACTION_INDEX_DOC_ID: "global";
+/**
+ * Apply an admin's overrides to the static base.
+ *
+ * Order is load-bearing: override, then DROP disabled, then append `custom`.
+ * Dropping last would let an admin disable an entry and have their own
+ * replacement for it disappear too, since a custom entry may legitimately
+ * reuse a built-in id to supersede it.
+ */
+export declare function mergeActionIndex(base: readonly ActionIndexEntry[], control: ActionIndexControl | undefined): ActionIndexEntry[];
+/**
+ * Drop every entry the viewer may not reach.
+ *
+ * 🛑 Filtered SERVER-side, never in the browser. An entry the client is not
+ * allowed to act on is an entry it must not receive: the label alone is a site
+ * map of the admin panel, which is D8's whole point.
+ */
+export declare function projectActionIndexForViewer(entries: readonly ActionIndexEntry[], viewer: {
+    role?: string;
+    permissions?: readonly string[];
+    isTester?: boolean;
+    isAdmin?: boolean;
+}): ActionIndexEntry[];