@aglyn/aglyn 1.0.0-beta.143

package/src/lib/plugin-manager/feature-plugins.js

@@ -0,0 +1,609 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * Feature-plugin pattern (AGL-277, AGL-395). Each feature ships as one lib
+ * under `libs/plugins/{feature}` (moved out of the old `.../ui/` nesting)
+ * that owns both halves and never merges into `plugins-mui` (which stays
+ * pure component/theme definitions):
+ *
+ *  - UI half → besigner/host components. Builds its bundle with
+ *    `defineUiFeatureBundle` (which depends on the mui bundle so
+ *    primitives/theming resolve first) and registers it with
+ *    `Aglyn.plugins.addDependency`, exactly like the mui bundle itself.
+ *    Registered per-editor via `register{Feature}Plugin()`.
+ *  - Console half → a `ConsoleExtension` registered with
+ *    `registerConsoleExtension` via a separate `register{Feature}Console()`
+ *    entry point (so app-load registration pulls no canvas code). The
+ *    console shell renders nav items + their pages, dashboard cards, and
+ *    settings sections from the registry, gated by the feature flag.
+ *
+ * This module is pure (no registry singletons) per app-utils layering;
+ * the plugin libs close the loop by passing `Aglyn.components` in.
+ * Reference implementation: events-calendar (AGL-313/394); commerce and
+ * email follow the same shape (AGL-290/346, relocated in AGL-395).
+ */ import { runInAction } from "mobx";
+/** The mui bundle id every UI feature bundle depends on. */ export const MUI_BUNDLE_ID = 'mui';
+/**
+ * UI half of the pattern: a plugin-registry bundle whose load/destroy
+ * register the feature's components + presets against the given
+ * registrar (`Aglyn.components` in apps), declared as depending on the
+ * mui bundle so the registry loads mui first.
+ */ export function defineUiFeatureBundle(options, registrar) {
+    var _options_dependsOn;
+    const dependencies = {
+        [MUI_BUNDLE_ID]: true
+    };
+    for (const id of (_options_dependsOn = options.dependsOn) != null ? _options_dependsOn : [])dependencies[id] = true;
+    return {
+        $id: options.bundleId,
+        displayName: options.displayName,
+        title: options.displayName,
+        description: options.description,
+        icon: options.icon,
+        dependencies,
+        load () {
+            // One mobx transaction per bundle (AGL-371): observers (component
+            // drawer, canvas) re-render once instead of once per registration.
+            runInAction(()=>{
+                for (const entry of options.components){
+                    registrar.registerComponent(entry.component, entry.schema);
+                }
+                for (const entry of options.components){
+                    var _entry_presets;
+                    if ((_entry_presets = entry.presets) == null ? void 0 : _entry_presets.length) registrar.registerPreset(entry.presets);
+                }
+            });
+        },
+        destroy () {
+            runInAction(()=>{
+                for (const entry of options.components){
+                    var _entry_presets;
+                    if ((_entry_presets = entry.presets) == null ? void 0 : _entry_presets.length) {
+                        registrar.unregisterPreset(entry.presets.map((preset)=>preset.$id));
+                    }
+                }
+                for (const entry of options.components){
+                    registrar.unregisterComponent(entry.schema.$id);
+                }
+            });
+        }
+    };
+}
+/**
+ * The injection-zone catalog (AGL-433, Strapi injection-zone parity):
+ * every named slot the console shell renders through `PluginWidgetSlot`,
+ * with what the slot receives. `slot` stays an open string so apps can
+ * add custom zones without a core release; these are the guaranteed ones.
+ */ export const CONSOLE_WIDGET_SLOTS = {
+    /** Host dashboard + screen view activity column. Props: hostId. */ hostActivity: 'hostActivity',
+    /**
+   * The host dashboard's glance row — one card per capability the site
+   * actually has. Props: hostId.
+   *
+   * The dashboard's own cards used to be imported by the page, which made
+   * enablement a decision nobody was making: `New site users` rendered on a
+   * site that has never turned member accounts on, and `Last campaign` on a
+   * workspace with the email plugin switched off. A card that answers a
+   * question about a capability belongs to the capability, so it registers
+   * here and the shell's entitlement + enablement gate decides.
+   */ hostDashboard: 'hostDashboard',
+    /**
+   * The organization's sites page, above the site grid (AGL-2636): the
+   * org-level twin of `hostDashboard`, for a card that totals the
+   * organization rather than one site. Props: `hostId` (always `null`),
+   * `orgMount` (the org and its sites — the {@link ConsolePluginOrgMount}
+   * the org-level hub page hands its plugin page), `basePath` (that hub's
+   * own path, `/[orgSlug]/crm`, for the links a widget builds when there is
+   * no site to derive them from).
+   *
+   * Every widget here reads ACROSS the host boundary — an org-wide total
+   * carries no scope clause — which is the one read a site collaborator may
+   * never make, so the page gates the whole row on the org hub's own access
+   * verdict before any widget mounts, and renders nothing at all (no empty
+   * row, no heading) when no widget survives the gates.
+   */ orgDashboard: 'orgDashboard',
+    /** Host dashboard commerce summary. Props: hostId, org. */ commerceGlance: 'commerceGlance',
+    /** Org Data page body. Props: orgId, org. */ orgData: 'orgData',
+    /** Besigner functions (ƒx) panel. Props: hostId. */ besignerFunctions: 'besignerFunctions',
+    /** Marketplace listing detail body. Props: hostId, listingId, permissions. */ marketplaceListing: 'marketplaceListing',
+    /**
+   * Org marketplace browse body (AGL-772). Props: hostId (acting site),
+   * permissions, orgScoped. The single org-scope place to browse + install,
+   * replacing the per-site marketplace tab.
+   */ orgMarketplace: 'orgMarketplace',
+    /** Plugins & add-ons hub installs section. Props: hostId. */ orgAddons: 'orgAddons',
+    /** Bottom of the host dashboard. Props: hostId, org. (AGL-433) */ dashboardFooter: 'dashboardFooter',
+    /** Org settings page, below the tabbed cards. Props: orgId, org. */ orgSettings: 'orgSettings',
+    /** Host setup page, below the built-in cards. Props: hostId, org. */ hostSettings: 'hostSettings',
+    /**
+   * The top of the page a newly created site lands on (AGL-2918): where a
+   * widget may offer to START the site for the person rather than leave them
+   * an empty one. Props: {@link ConsoleHostFirstRunZoneProps}.
+   *
+   * ── The blank path is the default, not the fallback ──────────────────────
+   *
+   * The site already exists, blank, and the page beneath this zone is the
+   * ordinary one every site gets. A widget here is an OFFER on top of that
+   * page: it asks the person what they want, it builds only what they then
+   * confirm, and everything it makes is a draft the site does not serve.
+   *
+   * So a zone with no widget — no plugin loaded, a feature not released, a
+   * reader without the permission — is not a degraded state. It is the blank
+   * path, unchanged and complete, which is why nothing on the page below
+   * depends on anything here.
+   *
+   * ── A widget here MUST offer `startBlank` ────────────────────────────────
+   *
+   * A guided start that a person cannot leave turns creating a site into a
+   * funnel, so `startBlank` is handed down rather than left to each widget to
+   * invent: a widget draws it where its questions START, not at the end of
+   * them, and taking it leaves the person on this same page with nothing
+   * begun behind them. The shell remembers the choice for this site and stops
+   * asking.
+   *
+   * A widget that takes the screen rather than sitting on the page — a full
+   * screen dialog, an overlay — owes the same exit in every shape it has one:
+   * a close control, and the key a person presses to dismiss it. Each of them
+   * is `startBlank`, because a takeover somebody can only dismiss BACK INTO is
+   * the funnel this zone exists to refuse, and nothing here is a half-answered
+   * state worth returning to.
+   */ hostFirstRun: 'hostFirstRun',
+    /**
+   * The host setup Theme section, between the "What you have changed" card
+   * and the editor (AGL-2938). Props: {@link ConsoleHostThemeZoneProps} — the
+   * site, the theme the editor shows, where that theme came from, the
+   * editor's own preview, and `proposeDraft`, which puts a theme in the
+   * editor as unsaved changes.
+   *
+   * A widget here proposes and never writes. The person saves what it
+   * proposed through the editor's own Save — the guarded write that stores
+   * an installed theme's edits as its override patch — or discards it. A
+   * palette importer, a brand kit and a generator are the same shape of
+   * widget.
+   */ hostTheme: 'hostTheme',
+    /**
+   * Staff admin org detail (staff-only surfaces). Props: orgId. A staff
+   * zone — see {@link CONSOLE_STAFF_WIDGET_SLOTS}.
+   */ adminOrgDetail: 'adminOrgDetail',
+    /**
+   * Billing → Usage, below the meters (AGL-2940). Props: `orgId`, `org` (the
+   * billing-merged org doc), `canManage` (the reader holds
+   * `billing.manage`). A card here explains or controls consumption the
+   * meters above it show.
+   */ orgBillingUsage: 'orgBillingUsage',
+    /**
+   * Billing → Overview, among the plan and add-on cards (AGL-2940). Props:
+   * `orgId`, `org`, `plan` (the page's own defaulted plan), `canManage`.
+   */ orgBillingOverview: 'orgBillingOverview',
+    /**
+   * The staff org page, among its cards (AGL-2940). Props: `orgId`. Staff
+   * only — the page is behind `StaffOnly`, and a widget here may read the
+   * staff-only routes. A staff zone — see {@link CONSOLE_STAFF_WIDGET_SLOTS}.
+   */ staffOrg: 'staffOrg',
+    /**
+   * The staff user page, below the account's activity. Props: `uid`. A
+   * staff zone — see {@link CONSOLE_STAFF_WIDGET_SLOTS}.
+   */ staffUser: 'staffUser',
+    /**
+   * A COLUMN of the staff Organizations list (AGL-2984) — see
+   * {@link ConsoleWidget.column}. The list renders the widget's component
+   * once per row with `{ row, orgId, orgIds }`: the row as the list route
+   * serves it, that row's org id, and every org id on the page, so a column
+   * that reads figures of its own asks once for the page rather than once
+   * per row. Its `Header` receives `{ orgIds }` beside the sort props. A
+   * staff zone — see {@link CONSOLE_STAFF_WIDGET_SLOTS}.
+   */ staffOrgsListColumn: 'staffOrgsListColumn',
+    /**
+   * The staff org usage table (AGL-2984): the monthly rollups on the staff
+   * org page and in the Organizations list's usage dialog. A widget with a
+   * `column` is a column of the table, between Forms and Cost, rendered once
+   * per month with `{ month, orgId }` — `month` is the rollup row as
+   * `/api/admin/org-usage` serves it. A widget without one renders above
+   * the table with `{ orgId, org }`, where `org` is the org document when the
+   * surface holds one and `undefined` when it does not. A staff zone — see
+   * {@link CONSOLE_STAFF_WIDGET_SLOTS}.
+   */ staffOrgUsageColumn: 'staffOrgUsageColumn',
+    /**
+   * The org's team member detail page, below the member's activity
+   * (AGL-2940). Props: `orgId`, `orgSlug`, `uid`, `member` (the org member
+   * document as the page loaded it), `hosts` (the org's sites, for naming
+   * them), `canManage` (the reader may manage the org).
+   */ orgMember: 'orgMember',
+    /**
+   * A COLUMN of the org Team table (AGL-2940) — see
+   * {@link ConsoleWidget.column}: the widget declares the header and the
+   * shell renders its component once per row with `{ member, orgId,
+   * canManage }`. A widget on this slot without a `column` renders nothing.
+   */ orgMembersListColumn: 'orgMembersListColumn',
+    /**
+   * The site collaborators card (AGL-2940). A widget with a `column` is a
+   * column of its table, rendered per row with `{ member, orgId, hostId,
+   * canManage }` — the owner's row too, with `member` carrying the owner's
+   * `uid` and `role: 'owner'`; a widget without one renders beneath the
+   * table with `{ hostId, canManage }`.
+   */ hostMembers: 'hostMembers',
+    /**
+   * The console shell's assistant dock (AGL-2940): the one position above
+   * every route boundary in both the `(app)` and `(editor)` shells, where a
+   * floating helper survives a navigation. Props: none — a widget here
+   * resolves its own scope from the URL, as the shell's own chrome does.
+   */ assistPanel: 'assistPanel',
+    /**
+   * A section at the bottom of the besigner's Attributes panel (AGL-2940),
+   * under the selected element's own fields. Props: `hostId` (`null` on an
+   * editor that names no site), and `node`, the selected element (AGL-2984)
+   * — present wherever the designer draws the panel for a selection.
+   */ besignerInspector: 'besignerInspector',
+    /**
+   * Inside a SEARCH LISTING editor (AGL-2910), under its fields. Props:
+   * {@link ConsoleSeoFieldsZoneProps} — what the listing describes, the
+   * fields the editor edits and what they hold, and `proposeValues`, which
+   * stages values in those fields as unsaved edits.
+   *
+   * Two editors host it: the screen detail page's SEO card, and the commerce
+   * product editor's search engine listing, which draws it through
+   * `useConsoleWidgetSlot` because a plugin's dialog cannot mount the shell's
+   * slot itself. A widget here proposes and never writes: the editor's own
+   * Save is the write, with the guards that write carries. A keyword checker,
+   * a translation memory and a generator are the same shape of widget.
+   */ seoFields: 'seoFields',
+    /**
+   * The host setup SEO section, above the site SEO form (AGL-2910). Props:
+   * {@link ConsoleHostSeoZoneProps} — the site, its stored SEO settings, and
+   * `proposeDraft`, which puts values in the form as unsaved edits. The
+   * form's Update stores them; nothing a widget proposes reaches the
+   * published site before that.
+   */ hostSeo: 'hostSeo',
+    /** {@link ConsoleRecordInsightsZoneProps} */ recordInsights: 'recordInsights',
+    /** {@link ConsoleRecordEmailZoneProps} */ recordEmail: 'recordEmail',
+    /** {@link ConsoleImportMappingZoneProps} */ importMapping: 'importMapping',
+    /**
+   * The besigner's secondary toolbar, after the undo and redo controls
+   * (AGL-2984), on every editor the designer opens: screens, layouts,
+   * components, forms, templates and email designs. A control here acts on
+   * the document in the editor. Props: `hostId` (`null` on an editor that
+   * names no site).
+   */ besignerToolbar: 'besignerToolbar',
+    /**
+   * A site's Screens page, beside its Templates and Create New Screen actions
+   * (AGL-2907): another way to start a screen. Props:
+   * {@link ConsoleHostScreensZoneProps}. A widget here runs its own flow and
+   * writes nothing through the page; the screens list shows what it makes once
+   * it exists.
+   */ hostScreens: 'hostScreens',
+    /**
+   * A site's Templates page, beside its Create Template action (AGL-3043):
+   * another way to start a template. Props:
+   * {@link ConsoleHostTemplatesZoneProps}. The `hostScreens` contract: a
+   * widget here runs its own flow and writes nothing through the page, and
+   * the template list shows what it makes once it exists.
+   */ hostTemplates: 'hostTemplates',
+    /**
+   * A site's Layouts page, beside its Templates and Create New Layout actions
+   * (AGL-3043): another way to start a layout. Props:
+   * {@link ConsoleHostLayoutsZoneProps}, on the `hostScreens` contract.
+   */ hostLayouts: 'hostLayouts',
+    /**
+   * The Forms page of a site, beside its Create Form action (AGL-3043):
+   * another way to start a form. Props: {@link ConsoleHostFormsZoneProps}, on
+   * the `hostScreens` contract.
+   *
+   * The Forms page is the forms plugin's own surface, so the plugin HOSTS
+   * this zone: it draws the renderer `useConsoleWidgetSlot` hands down, as
+   * the product editor draws `seoFields`, and every gate a console page's
+   * slot applies applies here too.
+   */ hostForms: 'hostForms',
+    /**
+   * A site's Components page, beside its Templates and Create Component
+   * actions (AGL-3051): another way to start a reusable component. Props:
+   * {@link ConsoleHostComponentsZoneProps}, on the `hostScreens` contract.
+   */ hostComponents: 'hostComponents',
+    /**
+   * The organization's sites page, beside the sites themselves (AGL-2911):
+   * an action a member takes across MANY of the org's sites at once, rather
+   * than a card totaling them. Props: {@link ConsoleOrgSitesZoneProps}.
+   *
+   * Distinct from `orgDashboard`, which is on the same page and gated on the
+   * org CRM hub's reach verdict because every card there reads across the
+   * host boundary. A widget here reads nothing of the kind: the sites it acts
+   * on are the ones the page already resolved for this reader, and its own
+   * door proves the reader's permission on each of them again. So the zone
+   * carries no gate beyond the slot's own — enablement, entitlement, and the
+   * widget's declared permission.
+   */ orgSites: 'orgSites',
+    /**
+   * The Automation page's Actions, beside Add action and Recipes (AGL-2919):
+   * another way to start an automation. Props:
+   * {@link ConsoleHostAutomationsZoneProps}.
+   *
+   * The Automation page is the workflows plugin's own surface, so the plugin
+   * HOSTS this zone through the renderer `useConsoleWidgetSlot` hands down, as
+   * the product editor hosts `seoFields`, and every gate a console page's slot
+   * applies applies here too. A widget here writes nothing through the page:
+   * the Actions list shows what it makes once it exists, and `openAction`
+   * opens a listed action in the Actions editor.
+   */ hostAutomations: 'hostAutomations',
+    /**
+   * The editor of one SAVED automation — an action or a workflow — on the
+   * Automation page (AGL-2919). Props: {@link ConsoleAutomationEditorZoneProps}.
+   * Hosted by the workflows plugin, as `hostAutomations` is. A widget here
+   * reads the automation as it is stored and changes nothing in the editor.
+   */ automationEditor: 'automationEditor',
+    /**
+   * One FAILED run in an automation's run history (AGL-2919), drawn once per
+   * failed row. Props: {@link ConsoleAutomationRunZoneProps}. Hosted by the
+   * workflows plugin. A widget here reads the run as it was recorded and
+   * changes nothing.
+   */ automationRun: 'automationRun',
+    /** The commerce product editor's fields (AGL-2916). Props: {@link ConsoleProductEditorZoneProps}. */ productEditor: 'productEditor',
+    /** Above the commerce products hub's catalog table (AGL-2916). Props: {@link ConsoleProductsHubZoneProps}. */ productsHub: 'productsHub',
+    /** Inside the commerce CSV import dialog (AGL-2916). Props: {@link ConsoleProductImportZoneProps}. */ productImport: 'productImport'
+};
+/**
+ * The zones on the STAFF pages (AGL-2939): the staff org page, its detail
+ * zone, and the staff user page.
+ *
+ * No workspace names the plugin set there. A staff page is ABOUT an org or
+ * an account, and the reader's own memberships have nothing to do with what
+ * it shows, so the console reads these zones from the plugins it loads for
+ * the staff area — every plugin that declares a `staff` register surface —
+ * and consults neither a widget's entitlement nor its permission: both are
+ * answers about a workspace, and the staff area's guard is what admits the
+ * reader.
+ */ export const CONSOLE_STAFF_WIDGET_SLOTS = [
+    CONSOLE_WIDGET_SLOTS.adminOrgDetail,
+    CONSOLE_WIDGET_SLOTS.staffOrg,
+    CONSOLE_WIDGET_SLOTS.staffUser,
+    CONSOLE_WIDGET_SLOTS.staffOrgsListColumn,
+    CONSOLE_WIDGET_SLOTS.staffOrgUsageColumn
+];
+/** Whether a slot is one of the {@link CONSOLE_STAFF_WIDGET_SLOTS}. */ export function isConsoleStaffWidgetSlot(slot) {
+    return CONSOLE_STAFF_WIDGET_SLOTS.includes(slot);
+}
+const consoleExtensions = new Map();
+/** Idempotent by pluginId — re-registration replaces the previous entry. */ export function registerConsoleExtension(extension) {
+    consoleExtensions.set(extension.pluginId, extension);
+}
+export function unregisterConsoleExtension(pluginId) {
+    consoleExtensions.delete(pluginId);
+}
+/**
+ * Registration-ordered extensions; the console shell filters by flag.
+ *
+ * AGL-758: the registry is a module-global that only ever grows — nothing
+ * outside tests unregisters, and loaded chunks can't unload — so after
+ * visiting two workspaces it holds the UNION of both plugin sets. Every
+ * read is therefore scoped by the caller's effective enabled set; pass the
+ * current org's plugin ids so one workspace never serves another's nav
+ * items, widgets, pages or providers. Omitting the argument keeps the
+ * unfiltered union (tests, and non-org surfaces that have no such set).
+ */ export function listConsoleExtensions(enabledPluginIds) {
+    const all = Array.from(consoleExtensions.values());
+    if (!enabledPluginIds) return all;
+    const enabled = new Set(enabledPluginIds);
+    return all.filter((extension)=>enabled.has(extension.pluginId));
+}
+/**
+ * Every registered nav item, flattened for the shell's nav strip. The
+ * shell appends these to its static tabs, so a plugin adds a menu item
+ * by registering here — no edit to the console's nav constants.
+ */ export function listConsoleNavItems(enabledPluginIds) {
+    return listConsoleExtensions(enabledPluginIds).flatMap((extension)=>{
+        var _extension_navItems;
+        return ((_extension_navItems = extension.navItems) != null ? _extension_navItems : []).map((navItem)=>_extends({}, navItem, {
+                pluginId: extension.pluginId,
+                featureFlag: extension.featureFlag
+            }));
+    });
+}
+/**
+ * One nav item against one href: exact, a declared section beneath it, or —
+ * for a nav item that asks — anything beneath it.
+ *
+ * A nav item that declares neither `sections` nor `ownsSubtree` matches its
+ * own href and nothing else. That is what keeps every plugin written before
+ * AGL-2501 behaving as it did: without it, prefix matching would quietly hand
+ * `/products/anything` to the Products page, which is the "it opened the wrong
+ * page" report rather than a 404.
+ */ function matchNavItem(navItem, href) {
+    var _navItem_legacyHrefs;
+    const current = matchNavItemHref(navItem, navItem.href, href);
+    if (current) return current;
+    for (const legacyHref of (_navItem_legacyHrefs = navItem.legacyHrefs) != null ? _navItem_legacyHrefs : []){
+        const match = matchNavItemHref(navItem, legacyHref, href);
+        if (match) return _extends({}, match, {
+            legacy: true
+        });
+    }
+    return undefined;
+}
+function matchNavItemHref(navItem, itemHref, href) {
+    var _navItem_sections, _navItem_sections1;
+    if (itemHref === href) return {
+        segments: []
+    };
+    if (!((_navItem_sections = navItem.sections) == null ? void 0 : _navItem_sections.length) && !navItem.ownsSubtree) return undefined;
+    // On a separator boundary, so `/products` cannot claim `/products-archive`.
+    if (!href.startsWith(`${itemHref}/`)) return undefined;
+    const segments = href.slice(itemHref.length + 1).split('/').filter(Boolean);
+    const section = (_navItem_sections1 = navItem.sections) == null ? void 0 : _navItem_sections1.find((item)=>item.id === segments[0]);
+    if (section) return {
+        section,
+        segments
+    };
+    // An id the nav item never declared is NOT this page — unless the surface
+    // claimed the subtree, in which case the deeper segments are its own
+    // entity ids and it answers for them. Returning the nav item otherwise
+    // would render the surface's default section under a URL naming a
+    // different one, which reads to the person who typed it as the wrong page
+    // opening rather than as a typo.
+    return navItem.ownsSubtree ? {
+        segments
+    } : undefined;
+}
+/**
+ * Resolves a host-relative href (e.g. '/events', '/products/orders') to the
+ * extension + nav item that owns a renderable page for it, and the section
+ * within it. The shell's generic host route uses this to render plugin pages
+ * without a per-plugin page file.
+ *
+ * ## Which registration wins (AGL-2501)
+ *
+ * LONGEST declared `href` wins, and an exact match therefore always beats a
+ * section match — an exact `href` spans the whole path, so nothing matching a
+ * prefix of it can be longer. `/products/orders` goes to a plugin that
+ * declares that path over one that declares `/products` with an `orders`
+ * section, and a prefix only matches on a SEGMENT boundary, so `/products`
+ * never claims `/products-archive`.
+ *
+ * A TIE REFUSES. Two enabled plugins matching the same path at the same length
+ * resolve to nothing, and the console 404s. Registry insertion order is an
+ * accident of which chunk loaded first, so picking from it means one
+ * workspace serves plugin A's page at a URL where another serves plugin B's —
+ * silently, and differently per session. Nobody can debug that from the
+ * symptom, so it is refused and logged instead. Two nav items of the SAME
+ * extension are not a tie: that order is authored, and the first wins as it
+ * always has.
+ *
+ * This is a rule rather than an accident because the registry is a
+ * session-wide UNION across plugins from different authors (AGL-758) — one
+ * plugin registering `/products` and another `/products/orders` is two
+ * workspaces' code meeting in one module-global, not one author's tidiness
+ * problem. Scoping is unchanged and load-bearing: every candidate still comes
+ * from `listConsoleExtensions(enabledPluginIds)`, so a plugin the current org
+ * has not enabled cannot win a path — or collide with one.
+ */ export function resolveConsolePluginPage(href, enabledPluginIds) {
+    return resolvePluginPageAmong(href, enabledPluginIds, (extension)=>extension.navItems);
+}
+/**
+ * Every registered {@link ConsoleExtension.orgNavItems} entry, in
+ * registration order, for the organization's tab strip (AGL-2974).
+ *
+ * Carries the extension whole rather than a flattened copy of two of its
+ * fields: a tab for a surface the reader cannot open is hidden, and deciding
+ * that takes the extension's `permission`, `featureFlag` and
+ * `upgradeNotice`, which is the same set the org route reads.
+ */ export function listConsoleOrgNavItems(enabledPluginIds) {
+    return listConsoleExtensions(enabledPluginIds).flatMap((extension)=>{
+        var _extension_orgNavItems;
+        return ((_extension_orgNavItems = extension.orgNavItems) != null ? _extension_orgNavItems : []).map((navItem)=>({
+                extension,
+                navItem
+            }));
+    });
+}
+/**
+ * {@link resolveConsolePluginPage} for the ORGANIZATION level (AGL-2974): an
+ * org-relative href (`/outreach/sequences`) against every enabled
+ * extension's `orgNavItems`, with the same matching, the same longest-href
+ * rule and the same refusal of a tie between two plugins. Site nav items are
+ * never candidates, so a surface registered under a site cannot be opened
+ * without one.
+ */ export function resolveConsoleOrgPluginPage(href, enabledPluginIds) {
+    return resolvePluginPageAmong(href, enabledPluginIds, (extension)=>extension.orgNavItems);
+}
+/** The resolver both levels share; `navItemsOf` picks which list is read. */ function resolvePluginPageAmong(href, enabledPluginIds, navItemsOf) {
+    let best;
+    /** Extensions matching at `best`'s length — more than one is the tie. */ let contenders = [];
+    for (const extension of listConsoleExtensions(enabledPluginIds)){
+        var _navItemsOf;
+        for (const navItem of (_navItemsOf = navItemsOf(extension)) != null ? _navItemsOf : []){
+            var _ref;
+            if (!navItem.Component) continue;
+            const match = matchNavItem(navItem, href);
+            if (!match) continue;
+            const bestLength = (_ref = best == null ? void 0 : best.navItem.href.length) != null ? _ref : -1;
+            if (navItem.href.length > bestLength) {
+                best = _extends({
+                    extension,
+                    navItem
+                }, match);
+                contenders = [
+                    extension.pluginId
+                ];
+                continue;
+            }
+            // Same length, different plugin: ambiguous. Same plugin: authored order,
+            // and the first nav item keeps the path.
+            if (navItem.href.length === bestLength && !contenders.includes(extension.pluginId)) {
+                contenders.push(extension.pluginId);
+            }
+        }
+    }
+    if (contenders.length > 1) {
+        // Loud, because the symptom — a 404 on a page that is plainly installed —
+        // names neither plugin. This line is the only place the collision is
+        // visible, so it carries both ids and the path they are fighting over.
+        console.error(`[aglyn] console page path "${href}" is claimed by more than one ` + `enabled plugin (${contenders.join(', ')}); refusing to guess which ` + 'one owns it. Change one plugin\'s nav item href.');
+        return undefined;
+    }
+    return best;
+}
+/**
+ * Every registered staff page, in registration order — the staff strip's
+ * plugin tabs, after the console's own.
+ */ export function listConsoleStaffPages(enabledPluginIds) {
+    return listConsoleExtensions(enabledPluginIds).flatMap((extension)=>{
+        var _extension_staffPages;
+        return ((_extension_staffPages = extension.staffPages) != null ? _extension_staffPages : []).map((page)=>_extends({}, page, {
+                pluginId: extension.pluginId
+            }));
+    });
+}
+/**
+ * The staff page at `/admin/{id}` (AGL-2939), or `undefined`.
+ *
+ * Two plugins claiming one id resolve to nothing, and say so: registry order
+ * is an accident of which chunk loaded first, and a staff page that is one
+ * plugin's on one load and another's on the next cannot be debugged from the
+ * symptom — the same rule {@link resolveConsolePluginPage} applies to paths.
+ */ export function resolveConsoleStaffPage(id, enabledPluginIds) {
+    const matches = listConsoleStaffPages(enabledPluginIds).filter((page)=>page.id === id);
+    const owners = [
+        ...new Set(matches.map((page)=>page.pluginId))
+    ];
+    if (owners.length > 1) {
+        console.error(`[aglyn] staff page "/admin/${id}" is claimed by more than one plugin ` + `(${owners.join(', ')}); refusing to guess which one owns it. ` + "Change one plugin's staff page id.");
+        return undefined;
+    }
+    return matches[0];
+}
+/** Widgets registered for a slot, across every extension (AGL-419). */ export function listConsoleWidgets(slot, enabledPluginIds) {
+    const out = [];
+    for (const extension of listConsoleExtensions(enabledPluginIds)){
+        var _extension_widgets;
+        for (const widget of (_extension_widgets = extension.widgets) != null ? _extension_widgets : []){
+            if (widget.slot === slot) out.push({
+                extension,
+                widget
+            });
+        }
+    }
+    return out;
+}
+/** Providers registered by every extension, in registration order. */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function listConsoleProviders(enabledPluginIds) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const out = [];
+    for (const extension of listConsoleExtensions(enabledPluginIds)){
+        var _extension_providers;
+        out.push(...(_extension_providers = extension.providers) != null ? _extension_providers : []);
+    }
+    return out;
+}
+
+//# sourceMappingURL=feature-plugins.js.map