@endora-commerce/admin-shell 0.0.0-stage → 0.100.0

package/dist/components/AppShell.js

@@ -0,0 +1,1259 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useFocusTrap } from './hooks/useFocusTrap.js';
+import { BrandLogo } from './BrandLogo.js';
+import { NavLink, Outlet, useLocation, useNavigate } from 'react-router-dom';
+import { Boxes, ChevronDown, ChevronRight, HelpCircle, Home as HomeIcon, Menu, LayoutDashboard, LogOut, PanelLeftClose, PanelLeftOpen, Search, Sparkles, } from 'lucide-react';
+import { useAuth } from '../lib/auth.js';
+import { cn } from '../lib/utils.js';
+import { useTranslation } from '../i18n/useTranslation.js';
+import { useTranslationContext } from '../i18n/TranslationProvider.js';
+import { registryNavFor, useAdminRegistry, } from '../lib/module-registry/index.js';
+import { LanguagePicker } from './LanguagePicker.js';
+import { useViewportTier } from './hooks/useViewportTier.js';
+import { NotificationBell } from './notifications/index.js';
+import { useAdminActions } from '../lib/admin-actions/useAdminActions.js';
+import { normalize } from '../lib/text-normalization.js';
+import { useModulePresence } from '../lib/module-presence/index.js';
+import { useSurfaceVisibility, } from '../lib/surface-visibility.js';
+import { resolveIcon } from '../lib/admin-actions/icon-map.js';
+import { getPromptCapability, listUnseenPromptRequests } from '../lib/prompt-actions/api.js';
+import { PromptModePanel } from './prompt-actions/PromptModePanel.js';
+import { SpeechToTextButton } from './SpeechToTextButton.js';
+/* Design-aligned navigation. The "Home" + "Orders" cluster sits above
+ * the first labelled group exactly as the prototype shows. */
+const NAV = [
+    {
+        key: 'main',
+        labelKey: '',
+        items: [
+            { to: '/', labelKey: 'appShell.nav.home', icon: LayoutDashboard, module: null },
+        ],
+    },
+    {
+        key: 'sales',
+        labelKey: 'appShell.section.sales',
+        items: [
+        // All three `/orders*` rows stood here until feature 091's Phase 4 batch
+        // 15; `orders` declares them now, at weights 100, 200 and 300 — the order
+        // they stood in — in `packages/modules/orders/src/admin/index.ts`. That
+        // *quick order is not a second destination but the other way of getting
+        // lines into the same order, so it lives behind a tab on the order-entry
+        // page* is still true and is recorded where the routes are.
+        //
+        // `/quote-requests`, `/invoices` and `/ksef` were declared here until
+        // feature 091's Phase 4 batch 12, at weights 400, 500 and 600 — the order
+        // they stood in here, and still the order they render in now that the
+        // three rows above them are contributions too.
+        //
+        // The section now holds **no host-declared row**, which has one
+        // operator-visible consequence recorded rather than glossed: the
+        // breadcrumb `registryCrumbs` derives for every screen in it renders
+        // *Sales* unlinked, because there is no host entry left for it to point
+        // at. That is batch 13's *Inventory* and *Pricing* arriving again, and it
+        // reaches the four contributed rows' trails as well as this module's own.
+        //
+        // `/ksef`'s glyph changes from `ReceiptText` to `Receipt`:
+        // `KnownIconNameSchema` does not carry the first, and `Receipt` is what
+        // this module's own `open-ksef` palette action has always named.
+        ],
+    },
+    {
+        key: 'catalog',
+        labelKey: 'appShell.section.catalog',
+        items: [
+        // All five `/catalog*` rows stood here until feature 091's Phase 4 batch
+        // 15; `catalog` declares them now, in
+        // `packages/modules/catalog/src/admin/index.ts`, at weights 10 to 50 —
+        // ten times the position rather than the usual hundred, because this
+        // section already holds three contributed rows and every one of them
+        // belongs *below* these five. `assets_library` declares 200, so
+        // `/catalog/categories` at 200 would tie with it and lose the tie-break
+        // on module id.
+        //
+        // The section now holds **no host-declared row**, so the derived
+        // breadcrumb renders *Catalog* unlinked — including on `pim_ergonode`'s
+        // five trails, whose own note recorded that crumb keeping its
+        // `/catalog/products` href while these rows were the host's.
+        //
+        // `/pim-ergonode` stood here until feature 091's Phase 4 batch 13.
+        // `pim_ergonode` declares it now, at weight 250 — between
+        // `assets_library`' 200 and `pim_pimcore`' 300, which is where both of
+        // those rows' own comments already said this one belonged and could not
+        // be while it was the host's, `composeNav` appending every registry entry
+        // after every host one. The reasoning that keeps it *one* row for five
+        // screens — the other four are reached through the tab strip on the
+        // connector page — is recorded where the routes are, in
+        // `packages/modules/pim_ergonode/src/admin/index.ts`.
+        //
+        // Feature 068's placement note stands and is why the section is *Catalog*
+        // rather than *Channels*: it is where catalogue content comes *from*, and
+        // the three surfaces it writes are its neighbours here.
+        ],
+    },
+    {
+        key: 'inventory',
+        labelKey: 'appShell.section.inventory',
+        items: [
+        // All five rows of this section stood here until feature 091's Phase 4
+        // batch 13; `inventory` declares them now, at weights 100 to 500 — the
+        // order they stood in — in
+        // `packages/modules/inventory/src/admin/index.ts`. The codes those
+        // declarations carry are the ones this table settled on 2026-08-29, when
+        // every one of the five stopped naming a module that owns none of the
+        // data behind them (`orders:read` for four screens about warehouses and
+        // stock, `catalog:write` for the CSV importer), and the importer keeps
+        // the `inventory:write` that separates it from the other four.
+        //
+        // The section now holds **no host-declared row**, which has one
+        // operator-visible consequence recorded rather than glossed: the
+        // breadcrumb `registryCrumbs` derives for these screens renders
+        // *Inventory* unlinked, because there is no host entry left for it to
+        // point at. That is batch 11's *Messaging* arriving a second time.
+        ],
+    },
+    {
+        key: 'pricing',
+        labelKey: 'appShell.section.pricing',
+        items: [
+        // `/price-lists` stood here until feature 091's Phase 4 batch 13.
+        // `price_lists` declares it now, at weight 100 — first in this section,
+        // which is where the operator has always seen it, and which is the whole
+        // of what keeps it above `taxes`' and `promotions`' 200 now that the host
+        // declares no row here at all. The same *Inventory* consequence applies:
+        // the derived breadcrumb renders *Pricing* unlinked.
+        //
+        // Carrier / payment gateway settings are reached as integrations from the
+        // Delivery methods / Payment methods pages (not top-level sidebar).
+        ],
+    },
+    {
+        key: 'customers',
+        labelKey: 'appShell.section.customers',
+        items: [
+        // `/customers`, `/customers/online` and `/organizations` stood here until
+        // feature 091's Phase 4 batch 14; `/comparisons` left in batch 6,
+        // `/customer-groups` in batch 7 and `/credit-limits` in batch 8. Every
+        // row in this section is the registry's now, ordered by the weights the
+        // four modules declare — 100, 200, 300, then 400 twice and 600 — which is
+        // the order the operator already had.
+        //
+        // **The any-of gate travels with the row.** `/organizations` is gated by
+        // `requireAdminAny(['customers:read', 'customers:manage'])`
+        // (`packages/modules/organizations/src/backend/routes.admin.ts:169`), and
+        // naming only the read code — as that entry did until 2026-08-29 — hid
+        // the screen from a role holding just `customers:manage`.
+        // `AdminNavDeclaration.requiredPermission` takes a `PermissionRequirement`
+        // for exactly this, so the array is declared unchanged in
+        // `packages/modules/organizations/src/admin/index.ts`.
+        //
+        // The section now holds **no host-declared row**, which has one
+        // operator-visible consequence recorded rather than glossed: the
+        // breadcrumb `registryCrumbs` derives for these screens renders
+        // *Customers* unlinked, because there is no host entry left for it to
+        // point at. That is batch 13's *Inventory* and *Pricing* arriving again.
+        ],
+    },
+    {
+        key: 'channels',
+        labelKey: 'appShell.section.channels',
+        items: [
+        // `/sales-channels` stood here until feature 091's Phase 4 batch 14;
+        // `/dictionary` and `/admin/dictionaries/audit` left in batch 10 and
+        // `/seo` in batch 8. Every row in this section is the registry's now, and
+        // `sales_channels` declares weight 100 against `dictionaries`' 200 and
+        // 300 and `seo`'s 400 — which is the order this table gave them while the
+        // first row was the host's and `composeNav` appended the rest. The
+        // *Customers* consequence above applies here too: the section holds no
+        // host-declared row, so the derived breadcrumb renders *Channels*
+        // unlinked.
+        ],
+    },
+    {
+        key: 'content',
+        labelKey: 'appShell.section.content',
+        items: [
+        // All seven rows of this section stood here until feature 091's Phase 4
+        // batch 16 — the four `/cms/…` and the three `/blog/…` — and `/megamenu`
+        // left in batch 8. `cms` and `blog` declare theirs now, at weights 100 to
+        // 400 and 600 to 800, in
+        // `packages/modules/{cms,blog}/src/admin/index.ts`. `megamenu` has
+        // declared 500 since batch 8 with a comment saying it sits after the four
+        // `/cms/…` rows and before the three `/blog/…` ones; it could not while
+        // both neighbours were the host's and `composeNav` appended every
+        // registry entry after every host one, and those seven weights are what
+        // make it true again.
+        //
+        // The section now holds **no host-declared row**, with the one
+        // operator-visible consequence every emptied section has: the breadcrumb
+        // `registryCrumbs` derives for these screens renders *Content* unlinked,
+        // because there is no host entry left for it to point at. That is batches
+        // 13's *Inventory* and *Pricing* and 14's *Customers* and *Channels*
+        // arriving one last time.
+        ],
+    },
+    {
+        key: 'messaging',
+        labelKey: 'appShell.section.messaging',
+        // **Empty on purpose** (feature 091, Phase 4 batch 11), which is
+        // `analyticsAds`' shape below. All three entries — `/transactional-emails`
+        // and its blocks and templates screens — are declared by
+        // `transactional_emails` and arrive through `composeNav` from
+        // `modules.generated.ts`. The section stays here because the shell owns the
+        // section taxonomy: `composeNav` refuses a contribution naming a section
+        // this file does not declare.
+        //
+        // With no host-declared entry left, the weights the module declares (100,
+        // 200, 300) are the whole of this section's order and reproduce exactly the
+        // order this table had.
+        items: [],
+    },
+    {
+        key: 'newsletter',
+        labelKey: 'appShell.section.newsletter',
+        // Empty on purpose, for the reason above and in the same batch: all six
+        // entries are `newsletter`'s, declared at weights 100 through 600, which is
+        // the order they stood in here.
+        items: [],
+    },
+    // Reporting and paid-acquisition surfaces. They were originally filed under
+    // System because each arrived as a lone integration, but together they are a
+    // domain an operator navigates to on purpose — not a system setting.
+    {
+        key: 'analyticsAds',
+        labelKey: 'appShell.section.analyticsAds',
+        // **Empty on purpose, and the first section that is** (feature 091, Phase 4
+        // batch three). All four of this section's entries — `/analytics`,
+        // `/google-analytics`, `/linkedin-ads`, `/meta-ads` — are now declared by
+        // the modules that own them and arrive through `composeNav` from
+        // `modules.generated.ts`. The section itself stays here because the shell
+        // owns the section taxonomy: `composeNav` refuses a contribution naming a
+        // section this file does not declare, since an entry in a section nobody
+        // renders is a surface that silently appears nowhere.
+        //
+        // The consequence is worth stating rather than discovering: with no
+        // host-declared entry left, `registryNavFor`'s `weight` is the whole of
+        // this section's order, and the weights the four modules declare (100, 200,
+        // 300, 400) reproduce exactly the order the hand-written table had. Batch
+        // one and batch two each recorded the append-to-the-end ordering as an
+        // operator-visible regression; this is where it is repaired.
+        items: [],
+    },
+    {
+        key: 'system',
+        labelKey: 'appShell.section.system',
+        items: [
+            // `module: null`, deliberately (D-36). This is the screen that switches
+            // modules on and off; attributing it to a module would mean the surface
+            // could switch itself out of existence, and nothing would be left to
+            // switch it back. It is gated on a permission, never on presence.
+            {
+                to: '/platform/modules',
+                labelKey: 'appShell.nav.platformModules',
+                icon: Boxes,
+                requiredPermission: 'platform.modules.read',
+                module: null,
+            },
+            // `/admin-users`, `/admin-roles` and `/audit-log` are declared by the
+            // modules that own them since feature 091's Phase 4 batch four, and
+            // arrive through `composeNav` from `modules.generated.ts` — including the
+            // split this file used to carry a comment about: the roles row is
+            // `admin_roles`' while the screen it points at is `admin_users`'. Their
+            // declarations, and that comment's reasoning, are in
+            // `packages/modules/{admin_users,admin_roles,audit_logs}/src/admin/index.ts`.
+            //
+            // Unlike *Analytics & Ads*, this section still holds host entries, so a
+            // registry entry appends after every one of them whatever its weight says
+            // — the operator-visible consequence the batch records.
+            // `/catalog/bulk-operations` stood here until feature 091's Phase 4 batch
+            // 15; `catalog` declares it now, at weight 400 — its position in this
+            // table's original thirteen rows, which is behind `/admin-roles`' 300 and
+            // ahead of `/custom-fields`' 500. One operator-visible change follows and
+            // is recorded rather than glossed: the row rendered *second* while it was
+            // the host's, `composeNav` putting every host row above every contributed
+            // one, and it renders fourth now — back where the table that wrote it put
+            // it. That *bulk operations may span many domains, so the entry lives
+            // under System while the URL stays `/catalog/bulk-operations` to keep
+            // existing deep links valid* is recorded where the route is.
+            // `/api-keys` and `/webhooks` are declared by the modules that own them
+            // since feature 091's Phase 4 (the plan's batch 6), and arrive through
+            // `composeNav` from `modules.generated.ts`. Their declarations are in
+            // `packages/modules/{api_keys,webhooks}/src/admin/index.ts`.
+            // `/credentials`, `/settings`, `/settings/groups` and `/settings/cache`
+            // are declared by the modules that own them since feature 091's Phase 4
+            // batch 10, and arrive through `composeNav` from `modules.generated.ts`.
+            // Their declarations are in
+            // `packages/modules/{credentials,settings}/src/admin/index.ts`.
+            //
+            // `/settings/pwa` is `pwa`'s and has been since batch six, when only the
+            // advertisement moved because the screen lived under
+            // `modules/settings/pages/`. Batch 10 moved that directory, so the screen
+            // went with it and the route is `pwa`'s too — the split closes rather
+            // than standing.
+        ],
+    },
+];
+const STORAGE_KEY = 'b2b-admin.nav.collapsed-groups';
+const RAIL_STORAGE_KEY = 'b2b-admin.nav.rail-mode';
+/**
+ * Rail (icon-only) mode persistence. The whole sidebar shrinks to a
+ * 64px-wide column showing just icons; section labels disappear and
+ * each section becomes a single icon (the first item's icon). Hovering
+ * or clicking the icon reveals a popover with the section's items.
+ */
+function loadRailMode() {
+    if (typeof window === 'undefined')
+        return false;
+    try {
+        return window.localStorage.getItem(RAIL_STORAGE_KEY) === '1';
+    }
+    catch {
+        return false;
+    }
+}
+function persistRailMode(value) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        window.localStorage.setItem(RAIL_STORAGE_KEY, value ? '1' : '0');
+    }
+    catch {
+        /* ignore */
+    }
+}
+function loadCollapsed() {
+    if (typeof window === 'undefined')
+        return new Set();
+    try {
+        const raw = window.localStorage.getItem(STORAGE_KEY);
+        if (!raw)
+            return new Set();
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            return new Set(parsed.filter((v) => typeof v === 'string'));
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return new Set();
+}
+function persistCollapsed(value) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        window.localStorage.setItem(STORAGE_KEY, JSON.stringify(Array.from(value)));
+    }
+    catch {
+        /* ignore */
+    }
+}
+const CRUMB_DICT = [
+    { test: /^\/$/, build: () => [{ labelKey: 'appShell.nav.home', href: null }] },
+    // Six hand-written `/catalog*` trails stood here until feature 091's Phase 4
+    // batch 15, and the two `/catalog/bulk-operations*` screens never had one at
+    // all — both fell to the humanised-segment fallback. `registryCrumbs` derives
+    // all eight now, from the sidebar entries `catalog` declares. Three
+    // operator-visible changes, stated rather than glossed:
+    //
+    //  - *Catalog* loses its link, this section holding no host-declared entry
+    //    any more for `registryCrumbs` to point at (batch 13's *Inventory* and
+    //    *Pricing*, arriving again).
+    //  - `/catalog/products/:id` loses its *Editor* leaf and reads
+    //    *Catalog → Products*, which is the shape every converted module's
+    //    sub-screen already gets.
+    //  - the two bulk-operation screens gain the label their sidebar row carries,
+    //    under *System* rather than under *Catalog*, which is the section that row
+    //    has declared since it was written.
+    // Seventeen hand-written trails stood here until feature 091's Phase 4 batch
+    // 13 — the five `/pim-ergonode*`, the four `/inventory*`, the three
+    // `/warehouses*`, the two `/price-lists*` — plus `/orders/quick-order`, which
+    // never had one and fell to the humanised-segment fallback.
+    // `registryCrumbs` derives all of them now, from the sidebar entries the four
+    // modules declare, which is what keeps a converted module's breadcrumb from
+    // being a third shared file to edit. Four operator-visible changes, stated
+    // rather than glossed:
+    //
+    //  - *Inventory* and *Pricing* lose their link, because neither section holds
+    //    a host-declared entry any more for `registryCrumbs` to point at (batch
+    //    11's *Messaging*, arriving again).
+    //  - Ergonode's five trails were three crumbs deep and are two: the derived
+    //    trail is *Catalog → <the entry's own label>*, and the leaf for the four
+    //    sub-screens becomes *Ergonode PIM* linked to nothing, because a nav
+    //    entry is a landing surface and these four have none of their own. The
+    //    three `appShell.nav.pimErgonode*` keys and `appShell.crumb.importRun`
+    //    that only these rules rendered are retired from `_i18n` with them.
+    //  - `/warehouses/new` and `/warehouses/:id` lose their *New* and *Edit*
+    //    leaves for the same reason, which is the shape every converted module's
+    //    sub-screen already gets.
+    //  - the *Catalog* crumb on the Ergonode trails keeps its `/catalog/products`
+    //    href, that being the section's first host-declared entry — the same
+    //    answer the hand-written rules gave.
+    // The two carrier trails — `/delivery-methods/dhl-parcel` and
+    // `/settings/inpost` — stood here until feature 134's wave 1 (FR-023, the
+    // extraction's per-wave prologue W1). They are the first two of the seven
+    // this table has left, and they retire for a reason the earlier batches did
+    // not have: **a host-owned crumb table may not declare a trail whose
+    // destination only a module declares.** Both routes are declared in
+    // `dhl_parcel`'s and `inpost`'s own admin layers and nowhere else, so this
+    // table was asserting a trail whose other end it cannot see — and a module
+    // that ships separately from this package takes its route declarations with
+    // it, at which point the rule describes nothing
+    // (`specs/conventions/module-admin-surfaces.md`).
+    // `registryCrumbs` derives both trails now. Three
+    // operator-visible changes, stated rather than glossed:
+    //
+    //  - `/delivery-methods/dhl-parcel` loses its *DHL Parcel* leaf and reads
+    //    *Pricing → Delivery methods*. Neither carrier contributes a sidebar
+    //    entry and neither is given one — that is the carriers' own
+    //    `plan.md` Ruling 1, and a nav row added to make a crumb derivable would
+    //    be a product change bought for a breadcrumb — so there is no contributed
+    //    row for `registryCrumbs` to build a leaf from. It is the shape every
+    //    converted module's sub-screen already gets.
+    //  - `/settings/inpost` reads *System → Settings*, and this one is **worse
+    //    than it was**, not merely shorter. `registryCrumbs` takes the longest
+    //    nav entry the path sits under, and `/settings/inpost` sits under
+    //    `settings`' own `/settings` rather than under anything the carrier
+    //    declares, so the trail names a screen the operator is not on. The route
+    //    is `inpost`'s own declaration, and it is moot in any instance that does
+    //    not install that module; the alternatives were giving `inpost` a sidebar
+    //    row it has never had, or keeping a host rule whose destination only the
+    //    module declares, and both are refused above.
+    //  - three `_i18n` keys retire, not two: the carriers' own pair, and the
+    //    shared **parent** key both trails named. That third one was kept out of
+    //    batch 8's sweep *explicitly* to parent these two trails —
+    //    `packages/modules/delivery_methods/src/admin/index.ts` says so, and says
+    //    it retires when they do — and after this it has no renderer at all; the
+    //    sidebar row resolves `nav.deliveryMethods.label` in `delivery_methods`'
+    //    own namespace. None of the three is spelled here on purpose:
+    //    `batch-eight-surfaces.module-owned-surface.test.tsx` asserts a retired
+    //    key's **absence from this file's source**, so naming one in a comment
+    //    about retiring it reds the assertion that proves it was retired.
+    // The two `/organizations*` trails stood here until feature 091's Phase 4
+    // batch 14, and the three `/customers*` screens never had one at all — they
+    // fell to the humanised-segment fallback. `registryCrumbs` derives all five
+    // now, from the sidebar entries the two modules declare. Two operator-visible
+    // changes, stated rather than glossed: the *Customers* crumb loses its link,
+    // that section holding no host-declared entry any more for `registryCrumbs`
+    // to point at (batch 13's *Inventory* and *Pricing*, arriving again), and
+    // `/organizations/:id` loses its *Detail* leaf — the shape every converted
+    // module's sub-screen already gets. The three `/customers*` screens gain the
+    // labels their sidebar rows already carry, where they had none.
+    // Five hand-written `/orders*` trails stood here until feature 091's Phase 4
+    // batch 15 — the roster, `/orders/new`, `/orders/quick-order`,
+    // `/orders/statuses` and the generic `/orders/:id`. `registryCrumbs` derives
+    // them from the three sidebar entries `orders` declares, and it gets the
+    // ordering property those five had by construction: it takes the **longest**
+    // matching entry, where this table took the first, which is why the three
+    // named sub-pages had to precede the generic rule here. Three
+    // operator-visible changes, stated rather than glossed:
+    //
+    //  - *Orders* becomes *Sales*, unlinked, on every one of these trails: the
+    //    derived trail names the section the module declares, and the section
+    //    holds no host entry left to link to.
+    //  - `/orders/:id` loses its *Detail* leaf and reads *Sales → Orders*, which
+    //    is the shape every converted module's sub-screen already gets. The
+    //    `appShell.crumb.detail` key nothing else rendered retires with it.
+    //  - `/orders/quick-order` loses its *Quick order* leaf for the same reason
+    //    and reads *Sales → Orders* too. `quick_order` declares a route and no
+    //    sidebar entry (batch 13), so there is no contributed row to derive a
+    //    leaf from; `appShell.nav.quickOrder` retires with the rule.
+    // The four `/invoices*` and `/quote-requests*` trails stood here until
+    // feature 091's Phase 4 batch 12. `registryCrumbs` derives all four now, out
+    // of the sidebar entries the two modules declare, and `/ksef` — which never
+    // had a trail at all and fell to the humanised-segment fallback — gains the
+    // label its sidebar row already carries. One operator-visible change, stated
+    // rather than glossed: these four named *Customers* as their section crumb
+    // and linked it to `/organizations`, while the sidebar rows they describe sit
+    // in *Sales*. The derived trail reads the section the module declares, so the
+    // crumb becomes *Sales* linked to `/orders` — the section's first host entry,
+    // which is what every hand-written trail in this table uses and what the
+    // sidebar has said all along.
+    // The two `/sales-channels*` trails stood here until feature 091's Phase 4
+    // batch 14. `registryCrumbs` derives both now, out of the sidebar entry
+    // `sales_channels` declares, with the same two changes the `/organizations`
+    // note above records: the *Channels* crumb loses its link and
+    // `/sales-channels/:code` loses its *Detail* leaf.
+    //
+    // The seven `/cms…` rules stood here until feature 091's Phase 4 batch 16,
+    // which is where the note above said they would retire. `registryCrumbs`
+    // derives ten of the eleven `/cms…` trails now, out of the four sidebar
+    // entries `cms` declares, and the seven `/blog/…` screens — which never had a
+    // hand-written trail at all and fell to the humanised-segment fallback — gain
+    // the labels their sidebar rows carry. Three operator-visible changes, stated
+    // rather than glossed:
+    //
+    //  * the section crumb becomes **Content**, unlinked. These seven rules named
+    //    *Channels* linked to `/sales-channels`, which was already the wrong
+    //    section — the sidebar has put these rows under *Content* for as long as
+    //    the section has existed — and `registryCrumbs` reads the section the
+    //    module declares. It is unlinked for the reason every emptied section's
+    //    is: there is no host-declared row left for it to point at;
+    //  * the six editor screens lose their `Editor` leaf and render
+    //    `Content / CMS Pages →`, which is the trail every converted module's
+    //    sub-screen already gets;
+    //  * `/cms` — the bare alias, which has no sidebar row and which
+    //    `registryCrumbs` therefore does not match — falls to the
+    //    humanised-segment fallback and renders a lone *cms*. It is the one trail
+    //    of the eleven that is worse than it was. Repairing it would mean either a
+    //    host `<Navigate>`, which moves a `cms` deep link into the admin's own
+    //    registry and is the direction this feature reverses, or a second sidebar
+    //    row for a path no operator is shown. Neither is worth an unadvertised
+    //    alias, and `/dictionaries/audit` took the same answer in batch 10.
+    // `/dictionary` and the two audit spellings had a hand-written trail here
+    // until feature 091's Phase 4 batch 10. `registryCrumbs` derives them now,
+    // from `dictionaries`' own nav contribution — two crumbs where the audit
+    // trail built three, the third having been a literal *audit* leaf there is
+    // nothing to derive. The unadvertised `/dictionaries/audit` spelling keeps
+    // resolving as a route and falls to the humanised-segment trail, which is
+    // what an unadvertised alias gets.
+    // `/admin-users`, `/admin-roles` and `/audit-log` had a hand-written trail
+    // here until feature 091's Phase 4 batch four. They are the modules' own
+    // declarations now, so `registryCrumbs` derives the trail from the composed
+    // sidebar — the label and the section come off the nav contribution, which is
+    // what stops this third registry from being a fifth shared file every
+    // converted module has to edit. Two consequences, both operator-visible and
+    // both stated rather than discovered: the section crumb's href becomes
+    // *System*'s first host entry, `/platform/modules`, where these three trails
+    // named `/admin-users` by hand; and the leaf label resolves in the owning
+    // module's namespace rather than in `core`.
+    { test: /^\/platform\/modules\/?$/, build: () => [
+            { labelKey: 'appShell.section.system', href: '/admin-users' },
+            { labelKey: 'appShell.nav.platformModules', href: null },
+        ] },
+    // `/settings` and `/settings/groups` had a hand-written trail here until
+    // feature 091's Phase 4 batch 10, and `/settings/cache` and `/settings/pwa`
+    // never had one at all — both fell to the humanised-segment fallback.
+    // `registryCrumbs` derives all four now, so the two that had a trail keep it
+    // with the section link corrected (*System*'s first host row is
+    // `/platform/modules`, where these named `/admin-users` by hand — batch
+    // four's recorded change, arriving again) and the two that had none gain the
+    // label their sidebar row already carries.
+    { test: /^\/profile\/?$/, build: () => [
+            { labelKey: 'appShell.crumb.myProfile', href: null },
+        ] },
+    // The six `/transactional-emails*` trails stood here until feature 091's
+    // Phase 4 batch 11. `registryCrumbs` derives all six now, out of the sidebar
+    // entries `transactional_emails` declares — which is what keeps a converted
+    // module's breadcrumb from being a third shared file to edit. Two of them
+    // change: the fragment editors lose their `Editor` leaf and render
+    // `Messaging / Email Blocks →` instead, which is the trail every other
+    // converted module's sub-screen already gets, and the *Messaging* crumb loses
+    // its link because that section now holds no host-declared entry for
+    // `registryCrumbs` to point at.
+];
+/**
+ * The trail for a screen a **module** contributes, derived from the composed
+ * sidebar (feature 091).
+ *
+ * `CRUMB_DICT` is a third host registry naming module routes by hand — this
+ * feature converts `App.tsx`'s and `AppShell.tsx`'s, and the plan does not
+ * cover this one. Deriving the leaf instead of adding an entry per module is
+ * what keeps a converted module's breadcrumb from being a fifth shared file to
+ * edit: the label and the section are already declared in the module's nav
+ * contribution, and the parent link is the section's own first host entry —
+ * exactly what every hand-written trail in this table uses.
+ *
+ * Returns `null` for a path no module claims, so `CRUMB_DICT` keeps precedence
+ * and the URL-segment fallback keeps the last word.
+ */
+function registryCrumbs(pathname, composedNav) {
+    const path = pathname.replace(/\/+$/, '') || '/';
+    let best = null;
+    for (const section of composedNav) {
+        for (const item of section.items) {
+            const labelScope = item.labelScope;
+            if (labelScope === undefined)
+                continue;
+            // The entry's own destination, or anything beneath it. A module's second
+            // and third routes (`/x/new`, `/x/:id`) have no sidebar row of their own
+            // and never will — a nav entry is a landing surface — so matching only
+            // the exact `to` would drop every converted module's sub-screens onto the
+            // humanised-segment fallback below. The hand-written trails this table is
+            // draining already covered subpaths that way, with the same shape.
+            if (item.to !== path && !path.startsWith(`${item.to}/`))
+                continue;
+            // **The longest match wins, and it is first-match no longer** (feature
+            // 091, batch 10). Until this batch no module contributed both a parent
+            // route and a child of it, so "the first entry that matches" and "the
+            // entry that matches most" were the same answer. `settings` contributes
+            // `/settings`, `/settings/groups` and `/settings/cache` and `pwa`
+            // contributes `/settings/pwa`; under first-match, all four screens would
+            // have rendered *Settings* as their leaf, because `/settings` sorts
+            // ahead of the rest by weight. That is a trail that no longer names where
+            // the operator is, which is the whole of what a breadcrumb does.
+            //
+            // `CRUMB_DICT` gets the same property for free by listing its specific
+            // patterns above its general ones; this is that ordering rule, derived
+            // instead of maintained.
+            if (best !== null && best.item.to.length >= item.to.length)
+                continue;
+            best = { section, item, labelScope };
+        }
+    }
+    if (best === null)
+        return null;
+    const { section, item, labelScope } = best;
+    const parent = section.items.find((other) => other.labelScope === undefined);
+    const trail = [];
+    if (section.labelKey) {
+        trail.push({ labelKey: section.labelKey, href: parent?.to ?? null });
+    }
+    trail.push({
+        labelKey: item.labelKey,
+        labelScope,
+        href: item.to === path ? null : item.to,
+    });
+    return trail;
+}
+function buildCrumbs(pathname, composedNav) {
+    for (const entry of CRUMB_DICT) {
+        const match = pathname.match(entry.test);
+        if (match)
+            return entry.build(match);
+    }
+    const contributed = registryCrumbs(pathname, composedNav);
+    if (contributed !== null)
+        return contributed;
+    // Keep real path segments in hrefs; only humanize the visible label.
+    const segments = pathname.split('/').filter(Boolean);
+    return segments.map((segment, idx) => ({
+        literal: segment.replace(/-/g, ' '),
+        href: idx === segments.length - 1 ? null : `/${segments.slice(0, idx + 1).join('/')}`,
+    }));
+}
+/**
+ * The palette's one matching rule, for every group it renders.
+ *
+ * Issue #233. The dialog merges three indexes and used to match with two
+ * different rules: the server-fed Actions group filters through `normalize`
+ * (`lib/text-normalization.ts`, applied in `lib/admin-actions/useAdminActions.ts`),
+ * which folds diacritics *and* the stroked letters NFD leaves standing, while
+ * the static Navigate group and the pinned Assistant row used a bare
+ * `toLowerCase().includes()`. Typing `zamowienia` therefore found the Actions
+ * row for orders and not the Navigate row for the same screen — and Polish
+ * operators routinely type without diacritics, so half the palette silently
+ * stopped answering them. Issue #236 then found a fourth copy in the
+ * page-builder drawer, which is why the fold now lives at
+ * `lib/text-normalization.ts` and not under `lib/admin-actions/`.
+ *
+ * `normalize` is **imported, not re-implemented**: the whole defect was one
+ * question answered twice, and a copy is how the two answers drifted apart. It
+ * folds `ł` through an explicit stroked-letter map, which matters — `ł` has no
+ * NFD decomposition, so the obvious `normalize('NFD').replace(...)` one-liner
+ * leaves `płatności` unmatched by `platnosci`.
+ *
+ * **Both sides are folded.** Folding only the haystack breaks the operator who
+ * does type `zamówienia`; folding only the query breaks the one who does not.
+ * (Postel's Law — accept what was typed and normalise it.)
+ *
+ * `needle` must already be normalised; the caller folds the query once per
+ * keystroke rather than once per row. `normalize` trims, so a query with a
+ * leading space matches what the operator meant rather than nothing at all
+ * (issue #236).
+ */
+function matchesQuery(needle, ...haystacks) {
+    return haystacks.some((haystack) => normalize(haystack).includes(needle));
+}
+/**
+ * The static Navigate group.
+ *
+ * **Every `requiredPermission` here is read from the backend route that gates
+ * the destination, not from the sidebar entry beside it.** Copying a neighbour
+ * is how a wrong code gets propagated twice, and several of these are not what
+ * the neighbourhood suggests:
+ *
+ *  - `/inventory`, `/warehouses`, `/inventory/low-stock` and
+ *    `/inventory/notifications` by `inventory:read`, and `/inventory/import` by
+ *    `inventory:write` — the module's own codes since 2026-08-29. Until then
+ *    all four reads said `orders:read` and the importer said `catalog:write`,
+ *    which is how a merchandiser came to be able to delete a warehouse and
+ *    anyone who could read orders came to be able to enumerate every warehouse
+ *    address (`packages/modules/inventory/src/backend/routes.admin.ts`);
+ *  - `/payment-methods` by `payment_methods:read` and `/delivery-methods` by
+ *    `delivery_methods:read`, each its owner's own code since 2026-08-28. They
+ *    look like a pair and are not one: the codes are separate, they are granted
+ *    separately, and neither is `catalog:read`, which is what both said until
+ *    the two modules stopped borrowing the catalogue's authority
+ *    (`packages/modules/payment_methods/src/backend/routes.ts:125`,
+ *    `packages/modules/delivery_methods/src/backend/routes.ts:106`);
+ *  - `/api-keys` and `/webhooks` by one shared `integrations:manage`
+ *    (`api_keys/routes.ts:20`, `webhooks/routes.ts:21`);
+ *  - `/dictionary` and its audit view by `dictionary.write` — the module
+ *    declares no read code, so reading the dictionary requires the write one
+ *    (`dictionaries/routes.admin.ts:72`);
+ *  - `/organizations` by `requireAdminAny(['customers:read',
+ *    'customers:manage'])`, which is why the field takes an any-of array.
+ *
+ * **Denied entries are hidden, not shown disabled** — the same treatment module
+ * absence already gets, and applied identically in the sidebar and in the
+ * dashboard's quick actions. Three reasons, in order of weight:
+ *
+ *  1. The Actions group in this very dialog already hides on permission;
+ *     `AdminActionsService` filters server-side before the row is sent. Showing
+ *     Navigate rows disabled would make one palette use two opposite treatments
+ *     for two groups the operator does not distinguish — identical-looking rows
+ *     that behave differently (Law of Similarity).
+ *  2. On an empty query the palette lists every Navigate entry. For a
+ *     single-domain role that is a wall of unusable rows in the surface whose
+ *     entire job is to shorten the path to the one thing you asked for (Hick).
+ *  3. Keyboard and pointer must reach the same conclusion. The Arrow/Enter loop
+ *     below indexes `items` directly, so a disabled row would still be
+ *     selectable by keyboard and `Enter` would navigate into a 403 — a
+ *     disabled-row design would need `aria-disabled`, a linked reason and cursor
+ *     skipping to be honest. Hiding makes the two paths identical by
+ *     construction and leaves nothing for a screen reader to announce.
+ *
+ * The cost of hiding is real and is answered elsewhere: "you do not have access
+ * to this" is actionable in a way "this module is not installed" is not, so it
+ * belongs at the point of failure — the 403 an operator reaches by bookmark or
+ * deep link — rather than in an index the operator is scanning for something
+ * else. That screen is not part of this change; see the report.
+ */
+const PALETTE_ITEMS = [
+    { group: 'Navigate', labelMode: 'key', label: 'appShell.nav.home', sub: 'appShell.palette.sub.dashboard', icon: HomeIcon, to: '/', keywords: 'home dashboard strona główna pulpit', module: null },
+    // The `/catalog/products`, `/catalog/categories` and `/catalog/attributes`
+    // rows left here in feature 091's Phase 4 batch 15, and they left by batch
+    // 10's route: `catalog` declared `new-product` and nothing that *opened* any
+    // of the three, so `open-products`, `open-categories` and `open-attributes`
+    // arrive with these rows' destinations, codes and keywords, and their labels
+    // and descriptions are the six strings the rows rendered, moved into that
+    // module's own bundle. The `/orders` row left in the same batch and was
+    // batch 12's case instead: `orders`' manifest already declared `open-orders`
+    // with the same destination and the same code, so the row was a second copy
+    // the server was never asked about and nothing replaces it.
+    // The `/inventory` and `/price-lists` rows left here in feature 091's Phase 4
+    // batch 13, and they left by the two routes batches 10 and 12 already
+    // established. `inventory` was batch 12's case: its manifest already declared
+    // `open-inventory` with the same destination and the same code, so the row
+    // was a second copy the server was never asked about and nothing replaces it.
+    // `price_lists` was batch 10's: it declared no action at all, so
+    // `open-price-lists` arrives with this row's destination, code and keywords,
+    // and its label and description are the two strings the row rendered, moved
+    // into that module's own bundle. Either way the advertisement is now the one
+    // surface the effective enabled-set filters.
+    // The `/organizations` row left here in feature 091's Phase 4 batch 14, and
+    // it left by batch 10's route: `organizations` declared no action at all, so
+    // `open-organizations` arrives with this row's destination and keywords, and
+    // its label and description are the two strings the row rendered, moved into
+    // that module's own bundle.
+    //
+    // **One operator-visible narrowing, recorded rather than glossed.** This row
+    // carried an any-of pair — `['customers:read', 'customers:manage']` — and
+    // `ModuleActionSchema.requiredPermission` is a single string
+    // (`packages/contracts/src/admin-actions.ts:205`), so the action names
+    // `customers:read`. A role holding only `customers:manage` therefore loses
+    // this palette entry and keeps the sidebar one, whose declaration takes the
+    // whole `PermissionRequirement` and keeps the pair. The screen stays
+    // reachable; only the second way of reaching it narrows. Widening the action
+    // schema would touch the palette resolver, the permission inventory and
+    // `check:action-route-permissions`, which is a change of its own and not a
+    // batch's.
+    // The `/quote-requests` row left here in feature 091's Phase 4 batch 12, and
+    // nothing replaced it: `quote_requests`' manifest already declares
+    // `open-rfq-inbox` with the same destination, the same code and the same
+    // keywords, so the row was a second copy of a declaration the server has been
+    // serving all along — and a copy the server was never asked about, which for
+    // a module an operator can withdraw means a palette that goes on advertising
+    // the screen after the withdrawal.
+    // The `/sales-channels` row left here in the same batch and by the same
+    // route. `sales_channels` declared `new-sales-channel` and nothing that
+    // *opened* the roster, so `open-sales-channels` arrives with this row's
+    // destination, code and keywords, and its label and description are the two
+    // strings the row rendered.
+    // The four `dictionaries`, `settings` and `credentials` rows left here in
+    // feature 091's Phase 4 batch 10. A hand-written palette row is a copy the
+    // server was never asked about — it went on advertising the screen after an
+    // operator withdrew the module — so each is a manifest **action** now, which
+    // is the surface the effective enabled-set filters. `settings` and
+    // `credentials` already declared theirs (`open-settings`, `open-credentials`,
+    // `new-credential`); `dictionaries` declares `open-dictionary` and
+    // `open-dictionary-audit` for the first time, with the destinations, codes
+    // and keywords these rows carried.
+    // Feature 020 — the Actions group is now sourced from the module
+    // registry via useAdminActions(); the previously-hardcoded "New
+    // product" and "Import products" entries are declared by the
+    // catalog and import_export module manifests respectively.
+];
+/**
+ * `[...hostNav, ...registryNav]`, per section (feature 091, FR-010;
+ * `contracts/admin-registry.md` R11).
+ *
+ * Built once at module scope because the registry is a static import: a
+ * contribution set cannot change without a rebuild, and recomputing it per
+ * render would allocate a new array on every keystroke in the palette input.
+ *
+ * **A module's entries append to their section**, ordered among themselves by
+ * `weight` then module id. R11 describes the end state — the whole section
+ * weight-ordered — which needs a weight on all 97 host entries and is Story 3's
+ * to deliver as it drains them; inventing one per host entry now would be a
+ * hundred numbers nothing derives. The consequence is visible and worth
+ * stating: `/import-export` used to sit between Credentials and Settings in the
+ * System group and now sits at that group's end.
+ *
+ * **A module may not invent a section** (D-23): `AdminNavSectionNameSchema` is
+ * closed, and a contribution naming a section this shell does not declare
+ * renders nowhere — so the composition refuses it here rather than dropping it
+ * silently.
+ */
+function composeNav(sections, entries) {
+    const declared = new Set(sections.map((section) => section.key));
+    for (const entry of entries) {
+        for (const item of entry.contributions.nav ?? []) {
+            if (declared.has(item.section))
+                continue;
+            throw new Error(`Module '${entry.moduleId}' contributes a sidebar entry in section '${item.section}', ` +
+                `which this shell does not declare. An entry in a section nobody renders is a ` +
+                `surface that silently appears nowhere.`);
+        }
+    }
+    return sections.map((section) => ({
+        ...section,
+        items: [
+            ...section.items,
+            ...registryNavFor(section.key, entries).map((item) => ({
+                to: item.to,
+                labelKey: item.labelKey,
+                labelScope: item.module,
+                icon: resolveIcon(item.icon),
+                // `exactOptionalPropertyTypes` — an ungated entry has no property,
+                // not a property holding `undefined`.
+                ...(item.requiredPermission === undefined
+                    ? {}
+                    : { requiredPermission: item.requiredPermission }),
+                module: item.module,
+            })),
+        ],
+    }));
+}
+/**
+ * The host's sections with every module's contributed entry folded in.
+ *
+ * A hook rather than a module constant (feature 110, T120), because the
+ * registry is now the admin project's value and arrives through
+ * `AdminRegistryProvider`: a constant evaluated at import time would have to
+ * read a file this package may not name. `useMemo` keys on the registry
+ * identity, which is a module-scope array in every real build, so the
+ * composition runs once per mount exactly as the constant did once per process
+ * — and `composeNav`'s refusal of an undeclared section now raises during
+ * render instead of during import, where a test can see which section it was.
+ */
+function useComposedNav() {
+    const entries = useAdminRegistry();
+    return useMemo(() => composeNav(NAV, entries), [entries]);
+}
+/**
+ * `t` for a nav entry's label, in whichever scope the entry declares.
+ *
+ * The host's entries resolve in `core` and a module's in its own namespace, and
+ * both go through the one translation context — a second resolver would be the
+ * drift issue #230 removed from the visibility question, in the label.
+ */
+function useNavLabel() {
+    const { t } = useTranslationContext();
+    return useCallback((item) => t(item.labelScope ?? 'core', item.labelKey), [t]);
+}
+export function AppShell() {
+    const { me, logout, hasPermission } = useAuth();
+    // The host's nav with every installed module's contributed entry folded in.
+    const composedNav = useComposedNav();
+    // Feature 073 — the effective enabled-set. A module that is off contributes
+    // no sidebar entry and no palette entry; neither surface recombines the two
+    // presence axes, because the server already did.
+    const { isPresent: isModulePresent } = useModulePresence();
+    const isVisible = useSurfaceVisibility();
+    const navigate = useNavigate();
+    const location = useLocation();
+    const [collapsed, setCollapsed] = useState(() => loadCollapsed());
+    const [railMode, setRailMode] = useState(() => loadRailMode());
+    const [paletteOpen, setPaletteOpen] = useState(false);
+    const [navDrawerOpen, setNavDrawerOpen] = useState(false);
+    const sidebarRef = useRef(null);
+    const viewportTier = useViewportTier();
+    const isMobile = viewportTier === 'mobile';
+    useFocusTrap(sidebarRef, isMobile && navDrawerOpen);
+    const toggleRailMode = useCallback(() => {
+        setRailMode((prev) => {
+            const next = !prev;
+            persistRailMode(next);
+            return next;
+        });
+    }, []);
+    const t = useTranslation('core');
+    const navLabel = useNavLabel();
+    // The raw, scope-taking resolver, for the breadcrumb: a crumb a module
+    // contributed resolves its label in that module's own namespace.
+    const { t: tScoped } = useTranslationContext();
+    const fullName = me ? `${me.adminUser.firstName} ${me.adminUser.lastName}`.trim() : '';
+    const role = me?.role?.name ?? 'Admin';
+    const toggleSection = useCallback((key) => {
+        setCollapsed((prev) => {
+            const next = new Set(prev);
+            if (next.has(key))
+                next.delete(key);
+            else
+                next.add(key);
+            persistCollapsed(next);
+            return next;
+        });
+    }, []);
+    // ⌘K opens the palette anywhere in the admin; ⌘B toggles the
+    // sidebar rail (matches the shadcn / VS Code shortcut convention).
+    useEffect(() => {
+        const onKey = (e) => {
+            // `!e.shiftKey` keeps ⌘K off Ctrl/⌘+Shift+K, which pages claim for
+            // their own in-page search (e.g. the Settings page's filter box).
+            if ((e.metaKey || e.ctrlKey) && !e.shiftKey && e.key.toLowerCase() === 'k') {
+                e.preventDefault();
+                setPaletteOpen(true);
+            }
+            else if (!isMobile &&
+                (e.metaKey || e.ctrlKey) &&
+                e.key.toLowerCase() === 'b') {
+                e.preventDefault();
+                toggleRailMode();
+            }
+            else if (e.key === 'Escape' && navDrawerOpen) {
+                setNavDrawerOpen(false);
+            }
+        };
+        window.addEventListener('keydown', onKey);
+        return () => window.removeEventListener('keydown', onKey);
+    }, [toggleRailMode, isMobile, navDrawerOpen]);
+    useEffect(() => {
+        setNavDrawerOpen(false);
+    }, [location.pathname]);
+    const crumbs = useMemo(() => buildCrumbs(location.pathname, composedNav), [location.pathname, composedNav]);
+    const isCmsRoute = location.pathname.startsWith('/cms');
+    return (_jsxs("div", { className: cn('b2b-app-layout', isMobile ? null : railMode ? 'b2b-app-layout--rail' : 'b2b-app-layout--expanded'), children: [isMobile && navDrawerOpen ? (_jsx("button", { type: "button", className: "b2b-nav-drawer-backdrop", "aria-label": t('appShell.mobileMenu.close'), onClick: () => setNavDrawerOpen(false) })) : null, _jsxs("aside", { ref: sidebarRef, className: cn('b2b-sidebar', railMode && !isMobile && 'b2b-sidebar--rail', isMobile && navDrawerOpen && 'b2b-sidebar--drawer-open'), "aria-hidden": isMobile && !navDrawerOpen ? true : undefined, role: "navigation", "aria-label": t('appShell.mobileMenu.title'), children: [_jsxs(NavLink, { to: "/", end: true, className: "b2b-sidebar__brand", style: { textDecoration: 'none', color: 'inherit', cursor: 'pointer' }, "aria-label": t('appShell.brand.dashboardLink'), title: railMode ? t('appShell.brand.text') : undefined, children: [_jsx("span", { className: "b2b-sidebar__brand-logo", children: _jsx(BrandLogo, { label: t('appShell.brand.text') }) }), _jsxs("span", { className: "b2b-sidebar__brand-text", children: [t('appShell.brand.textPrimary'), ' ', _jsx("span", { className: "b2b-sidebar__brand-text-accent", children: t('appShell.brand.textAccent') })] })] }), _jsx("div", { className: "b2b-sidebar__search", children: railMode ? (_jsx("button", { type: "button", className: "b2b-sidebar__search-rail", onClick: () => setPaletteOpen(true), title: t('appShell.search.openPalette'), "aria-label": t('appShell.search.openPalette'), children: _jsx(Search, { size: 16 }) })) : (_jsxs(_Fragment, { children: [_jsx(Search, { size: 14, className: "b2b-sidebar__search-icon" }), _jsx("input", { className: "b2b-sidebar__search-input", placeholder: t('appShell.search.placeholder'), readOnly: true, onClick: () => setPaletteOpen(true), onFocus: () => setPaletteOpen(true) }), _jsx("span", { className: "b2b-sidebar__search-kbd", children: t('appShell.search.shortcutSymbol') })] })) }), _jsx("nav", { className: "b2b-sidebar__nav", children: composedNav.map((section) => {
+                            const isOpen = !collapsed.has(section.key);
+                            // Permission-gate every entry, then presence-gate it (feature 073 /
+                            // FR-031). Sections with no remaining visible items fold away
+                            // entirely, which is what makes a whole domain disappear when every
+                            // module in it is off — the same behaviour restricted admins have
+                            // always had.
+                            //
+                            // Issue #230 — the predicate is `isSurfaceVisible`, shared with the
+                            // command palette and the dashboard quick actions. The palette used
+                            // to run a second, weaker copy of it; a shared helper is what stops
+                            // the three from disagreeing again.
+                            const visibleItems = section.items.filter(isVisible);
+                            if (visibleItems.length === 0)
+                                return null;
+                            // Feature 019 / 021 — section labels go through useTranslation('core').
+                            // The empty-labelKey "main" cluster keeps no label; every other
+                            // group resolves its declared `labelKey`. Polish strings live
+                            // in packages/modules/_i18n/i18n/pl.json under the same key.
+                            const translatedLabel = section.labelKey ? t(section.labelKey) : '';
+                            // In rail mode the section reduces to one icon (the first
+                            // visible item's icon). Hover or click reveals a popover
+                            // listing every visible item in the section.
+                            if (railMode) {
+                                return (_jsx(RailSection, { section: section, visibleItems: visibleItems, translatedLabel: translatedLabel }, section.key));
+                            }
+                            return (_jsxs("div", { className: cn('b2b-sidebar__group', !isOpen && section.labelKey && 'b2b-sidebar__group--collapsed'), children: [section.labelKey ? (_jsxs("button", { type: "button", className: "b2b-sidebar__group-label", onClick: () => toggleSection(section.key), children: [_jsx(ChevronDown, { size: 11 }), _jsx("span", { children: translatedLabel })] })) : null, _jsx("div", { className: "b2b-sidebar__items", children: visibleItems.map((item) => {
+                                            const Icon = item.icon;
+                                            // Force exact-match (`end`) when another item in the same
+                                            // section nests under this item's path. Without this, a
+                                            // parent route like `/inventory` lights up alongside its
+                                            // children (`/inventory/low-stock`, `/inventory/import`,
+                                            // …) because NavLink's default match is prefix-based.
+                                            // The home link (`/`) is the canonical example and is
+                                            // covered by the same rule (every other item starts with
+                                            // `/`).
+                                            const hasNestedSibling = section.items.some((other) => other !== item &&
+                                                other.to.startsWith(item.to === '/' ? '/' : `${item.to}/`));
+                                            return (_jsxs(NavLink, { to: item.to, end: item.to === '/' || hasNestedSibling, className: ({ isActive }) => cn('b2b-nav-item', isActive && 'is-active'), children: [_jsx(Icon, { size: 16 }), _jsx("span", { style: { flex: 1 }, children: navLabel(item) })] }, item.to));
+                                        }) })] }, section.key));
+                        }) }), me ? (_jsxs("div", { className: "b2b-sidebar__foot", children: [_jsxs(NavLink, { to: "/profile", className: "b2b-sidebar__foot-identity", title: railMode
+                                    ? `${fullName || me.adminUser.email} — ${t('appShell.profileMenu.profile')}`
+                                    : t('appShell.profileMenu.profile'), "aria-label": t('appShell.profileMenu.profile'), children: [_jsx("div", { className: "b2b-avatar", children: (fullName || me.adminUser.email).slice(0, 2).toUpperCase() }), _jsxs("div", { className: "meta", children: [_jsx("div", { className: "name", children: fullName || me.adminUser.email }), _jsx("div", { className: "role", children: role })] })] }), _jsx("button", { type: "button", className: "icon-btn", title: t('appShell.profileMenu.signOut'), "aria-label": t('appShell.profileMenu.signOut'), onClick: () => void logout(), children: _jsx(LogOut, { size: 14 }) })] })) : null, !isMobile ? (_jsxs("button", { type: "button", className: "b2b-sidebar__rail-toggle", onClick: toggleRailMode, title: railMode
+                            ? (t('appShell.sidebarToggle.expand') || 'Expand sidebar (⌘B)')
+                            : (t('appShell.sidebarToggle.collapse') || 'Collapse sidebar (⌘B)'), "aria-label": railMode
+                            ? (t('appShell.sidebarToggle.expand') || 'Expand sidebar')
+                            : (t('appShell.sidebarToggle.collapse') || 'Collapse sidebar'), "aria-pressed": railMode, children: [railMode ? _jsx(PanelLeftOpen, { size: 14 }) : _jsx(PanelLeftClose, { size: 14 }), !railMode ? (_jsx("span", { className: "b2b-sidebar__rail-toggle-label", children: t('appShell.sidebarToggle.collapse') || 'Collapse' })) : null] })) : null] }), _jsxs("div", { style: { minWidth: 0, display: 'flex', flexDirection: 'column' }, children: [_jsxs("div", { className: "b2b-topbar", children: [isMobile ? (_jsx("button", { type: "button", className: "b2b-topbar__menu-btn", "aria-label": t('appShell.mobileMenu.open'), "aria-expanded": navDrawerOpen, onClick: () => setNavDrawerOpen((open) => !open), children: _jsx(Menu, { size: 20 }) })) : null, _jsx("div", { className: isCmsRoute ? 'b2b-topbar__crumbs-inner b2b-page b2b-page--wide' : 'b2b-topbar__crumbs', children: crumbs.map((c, i) => (_jsxs("span", { style: { display: 'inline-flex', alignItems: 'center', gap: 6 }, children: [i > 0 ? _jsx(ChevronRight, { size: 12, className: "crumb-sep" }) : null, c.href ? (_jsx(NavLink, { to: c.href, className: "crumb-link", style: { color: 'inherit', textDecoration: 'none' }, children: c.labelKey !== undefined ? tScoped(c.labelScope ?? 'core', c.labelKey) : c.literal })) : (_jsx("span", { className: "crumb-cur", children: c.labelKey !== undefined ? tScoped(c.labelScope ?? 'core', c.labelKey) : c.literal }))] }, i))) }), _jsxs("div", { className: "b2b-topbar__actions", children: [_jsx("button", { type: "button", className: "b2b-topbar__icon-btn", title: t('appShell.search.openPalette'), "aria-label": t('appShell.search.openPalette'), onClick: () => setPaletteOpen(true), children: _jsx(Search, { size: 16 }) }), isModulePresent('admin_notifications') && hasPermission('admin:read') ? (_jsx(NotificationBell, {})) : null, _jsx("button", { type: "button", className: "b2b-topbar__icon-btn b2b-topbar__hide-mobile", title: t('appShell.topbar.help'), "aria-label": t('appShell.topbar.help'), children: _jsx(HelpCircle, { size: 16 }) }), _jsx("div", { style: { width: 1, height: 22, background: 'var(--border-color)', margin: '0 4px' } }), _jsx(LanguagePicker, {}), me ? (_jsx(NavLink, { to: "/profile", className: "b2b-avatar", title: `${fullName || me.adminUser.email} — ${t('appShell.profileMenu.profile')}`, "aria-label": t('appShell.profileMenu.profile'), style: { textDecoration: 'none', cursor: 'pointer' }, children: (fullName || me.adminUser.email).slice(0, 2).toUpperCase() })) : null] })] }), _jsxs("main", { className: "b2b-main", style: { flex: 1, overflow: 'auto' }, children: [_jsx("div", { className: "b2b-impersonation-slot", "data-impersonation-banner": true }), _jsx(Outlet, {})] })] }), _jsx(CommandPalette, { open: paletteOpen, onClose: () => setPaletteOpen(false), onNavigate: (to) => {
+                    navigate(to);
+                    setPaletteOpen(false);
+                } })] }));
+}
+function RailSection(props) {
+    const { section, visibleItems, translatedLabel } = props;
+    const navLabel = useNavLabel();
+    const [hover, setHover] = useState(false);
+    const [sticky, setSticky] = useState(false);
+    const wrapperRef = useRef(null);
+    const closeTimerRef = useRef(null);
+    const open = hover || sticky;
+    const location = useLocation();
+    // Active-state for the rail icon: light up when ANY visible item in
+    // the section matches the current URL (exact for the home route,
+    // prefix-with-segment-boundary for everything else).
+    const sectionActive = visibleItems.some((item) => {
+        if (item.to === '/')
+            return location.pathname === '/';
+        return (location.pathname === item.to ||
+            location.pathname.startsWith(`${item.to}/`));
+    });
+    const cancelClose = useCallback(() => {
+        if (closeTimerRef.current !== null) {
+            window.clearTimeout(closeTimerRef.current);
+            closeTimerRef.current = null;
+        }
+    }, []);
+    const scheduleClose = useCallback(() => {
+        cancelClose();
+        closeTimerRef.current = window.setTimeout(() => setHover(false), 120);
+    }, [cancelClose]);
+    // Click outside the wrapper closes the sticky popover.
+    useEffect(() => {
+        if (!sticky)
+            return;
+        const onDown = (e) => {
+            if (wrapperRef.current && !wrapperRef.current.contains(e.target)) {
+                setSticky(false);
+            }
+        };
+        window.addEventListener('mousedown', onDown);
+        return () => window.removeEventListener('mousedown', onDown);
+    }, [sticky]);
+    useEffect(() => () => cancelClose(), [cancelClose]);
+    const railSource = visibleItems[0] ?? section.items[0];
+    if (!railSource)
+        return null;
+    const RailIcon = railSource.icon;
+    const headerLabel = translatedLabel || (visibleItems[0] ? navLabel(visibleItems[0]) : '');
+    // Single-item section: render a plain link with no popover. The
+    // hover area is the link itself; tooltip carries the label.
+    if (visibleItems.length === 1) {
+        const only = visibleItems[0];
+        const Icon = only.icon;
+        const onlyLabel = navLabel(only);
+        return (_jsx("div", { className: "b2b-sidebar__rail-row", children: _jsx(NavLink, { to: only.to, end: only.to === '/', className: ({ isActive }) => cn('b2b-nav-item b2b-nav-item--rail', isActive && 'is-active'), title: onlyLabel, "aria-label": onlyLabel, children: _jsx(Icon, { size: 18 }) }) }));
+    }
+    return (_jsxs("div", { ref: wrapperRef, className: "b2b-sidebar__rail-row", onMouseEnter: () => {
+            cancelClose();
+            setHover(true);
+        }, onMouseLeave: scheduleClose, children: [_jsx("button", { type: "button", className: cn('b2b-nav-item b2b-nav-item--rail', sectionActive && 'is-active', open && 'is-open'), onClick: () => setSticky((prev) => !prev), "aria-haspopup": "menu", "aria-expanded": open, "aria-label": headerLabel, title: headerLabel, children: _jsx(RailIcon, { size: 18 }) }), open ? (_jsxs("div", { className: "b2b-sidebar__rail-popover", role: "menu", children: [headerLabel ? (_jsx("div", { className: "b2b-sidebar__rail-popover-header", children: headerLabel })) : null, visibleItems.map((item) => {
+                        const Icon = item.icon;
+                        const hasNestedSibling = visibleItems.some((other) => other !== item &&
+                            other.to.startsWith(item.to === '/' ? '/' : `${item.to}/`));
+                        return (_jsxs(NavLink, { to: item.to, end: item.to === '/' || hasNestedSibling, role: "menuitem", className: ({ isActive }) => cn('b2b-sidebar__rail-popover-item', isActive && 'is-active'), onClick: () => {
+                                setSticky(false);
+                                setHover(false);
+                            }, children: [_jsx(Icon, { size: 14 }), _jsx("span", { children: navLabel(item) })] }, item.to));
+                    })] })) : null] }));
+}
+/** Sentinel route for the assistant entry row — switches the palette mode
+ *  instead of navigating (feature 043; module_actions are navigation-only). */
+const PROMPT_MODE_SENTINEL = '__prompt_actions_mode__';
+/** Module-level capability cache: one fetch per session unless it failed. */
+let promptCapabilityCache = null;
+/** Test seam — interaction tests exercise multiple capability states. */
+export function resetPromptCapabilityCacheForTesting() {
+    promptCapabilityCache = null;
+}
+function CommandPalette(props) {
+    const { open, onClose, onNavigate } = props;
+    const t = useTranslation('core');
+    const tp = useTranslation('prompt_actions');
+    const { hasPermission } = useAuth();
+    const isVisible = useSurfaceVisibility();
+    const [query, setQuery] = useState('');
+    const [cursor, setCursor] = useState(0);
+    const [mode, setMode] = useState('search');
+    const [assistantReady, setAssistantReady] = useState(promptCapabilityCache === 'ready');
+    const [unseen, setUnseen] = useState([]);
+    const [initialRequest, setInitialRequest] = useState(undefined);
+    // Seed text carried into prompt mode by the `/ai <command>` palette shortcut.
+    const [initialPrompt, setInitialPrompt] = useState('');
+    const inputRef = useRef(null);
+    const { actions: registryActions } = useAdminActions(query);
+    // Feature 043 — capability probe, only when the operator may use the
+    // assistant. With the feature disabled/unconfigured (or the permission
+    // missing) the palette renders exactly as before (FR-015/FR-020, SC-006).
+    const mayUseAssistant = hasPermission('prompt_actions:use');
+    useEffect(() => {
+        if (!open || !mayUseAssistant || promptCapabilityCache !== null)
+            return;
+        void getPromptCapability()
+            .then((cap) => {
+            promptCapabilityCache = cap.status === 'ready' ? 'ready' : 'unavailable';
+            setAssistantReady(promptCapabilityCache === 'ready');
+        })
+            .catch(() => {
+            promptCapabilityCache = 'unavailable';
+        });
+    }, [open, mayUseAssistant]);
+    // FR-018 — completion notice: prompts that finished while the palette was
+    // closed surface on the next open until acknowledged.
+    useEffect(() => {
+        if (!open || !mayUseAssistant || !assistantReady) {
+            setUnseen([]);
+            return;
+        }
+        void listUnseenPromptRequests()
+            .then(setUnseen)
+            .catch(() => setUnseen([]));
+    }, [open, mayUseAssistant, assistantReady]);
+    // Map registry-supplied actions into the local PaletteItem shape so
+    // the rendering loop stays uniform across Navigate (static) and
+    // Actions (registry-driven) groups.
+    const actionItems = useMemo(() => registryActions.map((a) => ({
+        group: 'Actions',
+        labelMode: 'literal',
+        label: a.label,
+        sub: a.description ?? '',
+        icon: resolveIcon(a.icon),
+        to: a.targetRoute,
+        // Carried for shape uniformity only: an Actions row is filtered by
+        // `useAdminActions(query)` before it reaches this mapper, so nothing
+        // below reads this field. Kept unfolded — `matchesQuery` normalises
+        // its haystack at compare time, and a second, differently-normalised
+        // copy of the same data is what issue #233 was about.
+        keywords: a.keywords.join(' '),
+    })), [registryActions]);
+    // Feature 073 / FR-032 plus issue #230 — the Navigate group, filtered on both
+    // axes by the same predicate the sidebar uses. The Actions group needs nothing
+    // here: the server already resolves both axes for it.
+    const navigateItems = useMemo(() => PALETTE_ITEMS.filter(isVisible), [isVisible]);
+    // Build a derived view that translates Navigate-group keys at render
+    // time and leaves the registry-supplied Actions strings untouched.
+    const resolveLabel = (it) => it.labelMode === 'key' ? t(it.label) : it.label;
+    const resolveSub = (it) => it.labelMode === 'key' ? t(it.sub) : it.sub;
+    // Feature 043 — pinned assistant entry (only when enabled + configured +
+    // permitted). Always listed first; matched generously while typing.
+    const assistantItems = useMemo(() => {
+        if (!mayUseAssistant || !assistantReady)
+            return [];
+        return [
+            {
+                group: 'Assistant',
+                labelMode: 'literal',
+                label: tp('palette.entry.label'),
+                sub: tp('palette.entry.description'),
+                icon: Sparkles,
+                to: PROMPT_MODE_SENTINEL,
+                keywords: 'assistant ai prompt ask asystent zapytaj',
+            },
+        ];
+    }, [mayUseAssistant, assistantReady, tp]);
+    const items = useMemo(() => {
+        if (!query.trim())
+            return [...assistantItems, ...navigateItems, ...actionItems];
+        // Folded once here, then compared against every row — see `matchesQuery`.
+        const q = normalize(query);
+        const filteredAssistant = assistantItems.filter((i) => matchesQuery(q, i.label, i.sub, i.keywords));
+        // Navigate group: filter against the *translated* label + sub plus
+        // the raw keywords list so a Polish user can search in Polish and
+        // an English user in English.
+        const filteredNav = navigateItems.filter((i) => matchesQuery(q, resolveLabel(i), resolveSub(i), i.keywords));
+        return [...filteredAssistant, ...filteredNav, ...actionItems];
+        // `resolveLabel` / `resolveSub` are render-scoped closures over `t`; the
+        // list re-derives on every language change through the parent re-render.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [query, actionItems, assistantItems, navigateItems]);
+    // Activating the assistant row switches the palette body instead of
+    // navigating (feature 043); everything else keeps the navigation path.
+    const activate = useCallback((to) => {
+        if (to === PROMPT_MODE_SENTINEL) {
+            setInitialPrompt('');
+            setMode('prompt');
+            return;
+        }
+        onNavigate(to);
+    }, [onNavigate]);
+    // `/ai` shortcut: typing `/ai` (optionally followed by a command) in the
+    // palette input launches prompt mode directly, carrying any typed command
+    // into the assistant input — equivalent to opening "Ask the assistant" and
+    // typing it. Only intercepts when the assistant is actually usable.
+    const handleQueryChange = useCallback((value) => {
+        const match = /^\/ai(?:\s+(.*))?$/i.exec(value);
+        if (match && mayUseAssistant && assistantReady) {
+            setQuery('');
+            setInitialPrompt(match[1] ?? '');
+            setMode('prompt');
+            return;
+        }
+        setQuery(value);
+    }, [mayUseAssistant, assistantReady]);
+    useEffect(() => {
+        setCursor(0);
+    }, [query, open]);
+    useEffect(() => {
+        if (!open) {
+            setQuery('');
+            setMode('search');
+            setInitialRequest(undefined);
+            setInitialPrompt('');
+        }
+    }, [open]);
+    useEffect(() => {
+        if (!open)
+            return;
+        if (mode === 'prompt') {
+            // Prompt mode owns its own inputs; only Esc is handled here — it
+            // returns to the classic palette rather than closing (research §R9).
+            const onKey = (e) => {
+                if (e.key === 'Escape') {
+                    e.stopPropagation();
+                    setMode('search');
+                }
+            };
+            window.addEventListener('keydown', onKey);
+            return () => window.removeEventListener('keydown', onKey);
+        }
+        inputRef.current?.focus();
+        const onKey = (e) => {
+            if (e.key === 'ArrowDown') {
+                e.preventDefault();
+                setCursor((c) => Math.min(items.length - 1, c + 1));
+            }
+            else if (e.key === 'ArrowUp') {
+                e.preventDefault();
+                setCursor((c) => Math.max(0, c - 1));
+            }
+            else if (e.key === 'Enter') {
+                e.preventDefault();
+                const it = items[cursor];
+                if (it)
+                    activate(it.to);
+            }
+            else if (e.key === 'Escape') {
+                onClose();
+            }
+        };
+        window.addEventListener('keydown', onKey);
+        return () => window.removeEventListener('keydown', onKey);
+    }, [open, mode, items, cursor, onClose, activate]);
+    if (!open)
+        return null;
+    if (mode === 'prompt') {
+        return (_jsxs(_Fragment, { children: [_jsx("div", { className: "b2b-scrim", onClick: onClose }), _jsx("div", { className: "b2b-palette", role: "dialog", "aria-modal": "true", children: _jsx(PromptModePanel, { onExit: () => {
+                            setInitialRequest(undefined);
+                            setInitialPrompt('');
+                            setMode('search');
+                        }, ...(initialRequest ? { initialRequest } : {}), ...(initialPrompt ? { initialPrompt } : {}) }) })] }));
+    }
+    let lastGroup = '';
+    return (_jsxs(_Fragment, { children: [_jsx("div", { className: "b2b-scrim", onClick: onClose }), _jsxs("div", { className: "b2b-palette", role: "dialog", "aria-modal": "true", children: [_jsxs("div", { className: "b2b-palette__input", children: [_jsx(Search, { size: 18, style: { color: 'var(--fg-muted)' } }), _jsx("input", { ref: inputRef, placeholder: t('appShell.search.commandPalettePlaceholder'), value: query, onChange: (e) => handleQueryChange(e.target.value) }), _jsx(SpeechToTextButton, { startTitle: t('appShell.search.voiceInput'), stopTitle: t('appShell.search.voiceInputStop'), onTranscript: (text) => {
+                                    setQuery((q) => (q ? `${q} ${text}` : text));
+                                    inputRef.current?.focus();
+                                } }), _jsx("span", { className: "b2b-kbd-sm", children: "esc" })] }), _jsxs("div", { className: "b2b-palette__list", children: [unseen.length > 0 ? (_jsxs("div", { "data-testid": "prompt-unseen-notice", className: "b2b-palette__item", style: { cursor: 'pointer' }, onClick: () => {
+                                    setInitialRequest(unseen[0]);
+                                    setUnseen((u) => u.slice(1));
+                                    setMode('prompt');
+                                }, children: [_jsx(Sparkles, { size: 16 }), _jsx("div", { children: _jsx("div", { children: tp('panel.unseenNotice') }) })] })) : null, items.length === 0 ? (_jsx("div", { style: { padding: 32, textAlign: 'center', color: 'var(--fg-muted)', fontSize: 13 }, children: t('appShell.search.noMatches') })) : (items.map((it, i) => {
+                                const showGroup = it.group !== lastGroup;
+                                lastGroup = it.group;
+                                const Icon = it.icon;
+                                const groupHeader = it.group === 'Navigate'
+                                    ? t('appShell.palette.group.navigate')
+                                    : it.group === 'Assistant'
+                                        ? tp('palette.group.label')
+                                        : t('appShell.palette.group.actions');
+                                const label = resolveLabel(it);
+                                const sub = resolveSub(it);
+                                return (_jsxs("div", { children: [showGroup ? _jsx("div", { className: "b2b-palette__group", children: groupHeader }) : null, _jsxs("div", { className: cn('b2b-palette__item', i === cursor && 'is-cur'), onMouseEnter: () => setCursor(i), onClick: () => activate(it.to), children: [_jsx(Icon, { size: 16 }), _jsxs("div", { children: [_jsx("div", { children: label }), _jsx("div", { style: { fontSize: 11, color: 'var(--fg-muted)' }, children: sub })] }), _jsx("span", { className: "meta", children: i === cursor ? _jsx("span", { className: "b2b-kbd-sm", children: "\u21B5" }) : null })] })] }, `${it.group}-${it.label}`));
+                            }))] })] })] }));
+}
+//# sourceMappingURL=AppShell.js.map