@snap-rail/framework-shadcn 0.0.0-stage → 0.2.0

package/lib/types/semantic.d.ts

@@ -0,0 +1,55 @@
+/** Framework-neutral semantic UI contributions.
+ *
+ * Layouts own the visual arrangement. Components publish views, navigation
+ * entries and actions against stable semantic slots, so the same component can
+ * move between layouts without importing a layout package.
+ *
+ * @module @snap-rail/framework-shadcn/semantic
+ */
+import { Context, type Plugin } from '@snap-rail/cordis';
+import type { ReactNode } from 'react';
+import type { SlotId, SlotOccupant } from './slots.tsx';
+/** A view contributed by a UI component plugin. */
+export interface UiViewContribution extends SlotOccupant {
+    /** Human-facing label for menus and accessibility surfaces. */
+    title: string;
+    /** The semantic slot where the view is rendered. */
+    slot: SlotId;
+}
+/** A layout contribution that consumes semantic slots. */
+export interface UiLayoutContribution extends SlotOccupant {
+    /** Slots this layout defines and renders. */
+    slots: readonly SlotId[];
+}
+/** A navigation entry that targets a contributed view id. */
+export interface UiNavigationContribution {
+    id: string;
+    label: string;
+    viewId: string;
+    order: number;
+    /** Optional leading visual for layouts that render navigation items —
+     * the component renders its own SVG/asset, the layout only places it. */
+    icon?: ReactNode;
+}
+/** The shared UI contract service exposed to all client plugins. */
+export interface UiContractService {
+    registerView(caller: Context, contribution: UiViewContribution): () => void;
+    registerLayout(caller: Context, contribution: UiLayoutContribution): () => void;
+    registerNavigation(caller: Context, contribution: UiNavigationContribution): () => void;
+    listViews(): readonly UiViewContribution[];
+    listLayouts(): readonly UiLayoutContribution[];
+    listNavigation(): readonly UiNavigationContribution[];
+}
+declare module '@snap-rail/cordis' {
+    interface Context {
+        uiContract: UiContractService;
+    }
+    interface Events {
+        'ui/semantic-changed'(kind: 'view' | 'layout' | 'navigation'): void;
+        /** A contribution used an unknown or malformed semantic slot. */
+        'ui/semantic-invalid'(kind: 'view' | 'layout', id: string, slot: string): void;
+    }
+}
+/** Mount the semantic contribution registry on top of the slot registry. */
+declare const semanticPlugin: Plugin.Object<void>;
+export default semanticPlugin;

package/lib/types/semantic.js

@@ -0,0 +1,63 @@
+/** Framework-neutral semantic UI contributions.
+ *
+ * Layouts own the visual arrangement. Components publish views, navigation
+ * entries and actions against stable semantic slots, so the same component can
+ * move between layouts without importing a layout package.
+ *
+ * @module @snap-rail/framework-shadcn/semantic
+ */
+import { Context } from '@snap-rail/cordis';
+import { isValidUiSlotId, UI_SLOT_IDS } from "./slots.js";
+/** Mount the semantic contribution registry on top of the slot registry. */
+const semanticPlugin = {
+    name: 'framework semantic ui contract',
+    inject: ['uiSlots'],
+    apply(ctx) {
+        const slots = ctx.uiSlots;
+        const views = new Map();
+        const layouts = new Map();
+        const navigation = new Map();
+        let sequence = 0;
+        const ordered = (values) => [...values].sort((a, b) => a.value.order - b.value.order || a.seq - b.seq).map(item => item.value);
+        const register = (table, caller, id, value, disposeSlot) => {
+            table.set(id, { value, seq: sequence++ });
+            const kind = table === views ? 'view' : table === layouts ? 'layout' : 'navigation';
+            ctx.emit('ui/semantic-changed', kind);
+            const remove = () => {
+                // Disposal is by contribution id: an earlier handle still removes the
+                // entry after a same-id replacement (fiber unload drops the current
+                // contribution), and repeat calls are no-ops.
+                if (!table.delete(id))
+                    return;
+                disposeSlot?.();
+                ctx.emit('ui/semantic-changed', kind);
+            };
+            caller.effect(() => remove);
+            return remove;
+        };
+        const validateSlot = (kind, id, slot) => {
+            if (!isValidUiSlotId(slot))
+                ctx.emit('ui/semantic-invalid', kind, id, slot);
+        };
+        ctx.provide('uiContract', {
+            registerView(caller, contribution) {
+                validateSlot('view', contribution.id, contribution.slot);
+                const disposeSlot = slots.register(caller, contribution.slot, contribution);
+                return register(views, caller, contribution.id, contribution, disposeSlot);
+            },
+            registerLayout(caller, contribution) {
+                for (const slot of contribution.slots)
+                    validateSlot('layout', contribution.id, slot);
+                const disposeSlot = slots.register(caller, UI_SLOT_IDS.layout, contribution);
+                return register(layouts, caller, contribution.id, contribution, disposeSlot);
+            },
+            registerNavigation(caller, contribution) {
+                return register(navigation, caller, contribution.id, contribution);
+            },
+            listViews: () => ordered(views.values()),
+            listLayouts: () => ordered(layouts.values()),
+            listNavigation: () => ordered(navigation.values()),
+        });
+    },
+};
+export default semanticPlugin;

package/lib/types/session.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The operator session seam: `ctx.session` mirrors the host-side session
+ * (persisted to settings, so a restart keeps the operator signed on) and
+ * re-emits `session/changed` on every transition — its own writes and any
+ * host-side change that rides the `settings/changed` frame. The login page
+ * writes it; every workflow consumer reads it for gating and audit
+ * attribution.
+ *
+ * @module @snap-rail/framework-shadcn/session
+ */
+import '@snap-rail/station-rpc/contract';
+import { type Plugin } from '@snap-rail/cordis';
+declare module '@snap-rail/cordis' {
+    interface Context {
+        session: SessionService;
+    }
+    interface Events {
+        /** The signed-on operator changed (login, logout, or boot restore).
+         * @param operator - the new operator id, or `null` when signed off.
+         */
+        'session/changed'(operator: string | null): void;
+        /** The boot-time restore probe settled (success or failure) — the one
+         * tick where `current()` first reflects the persisted operator. */
+        'session/restored'(): void;
+    }
+}
+/** Operator session exposed on `ctx.session`. */
+export interface SessionService {
+    /** The signed-on operator id, or `null` while the login page shows. */
+    current(): string | null;
+    /** Whether the boot-time restore probe has settled. Until it does,
+     * `current()` is not yet the truth (a restart may still be about to
+     * restore a persisted operator) — consumers must not render the login
+     * page or gate workflows on `current()` before this holds. */
+    restored(): boolean;
+    /** Sign an operator on; trims the id and rejects empty input. */
+    login(operator: string): Promise<void>;
+    /** Sign the current operator off (back to the login page). */
+    logout(): Promise<void>;
+}
+/** Mounts the `ctx.session` mirror; state lives in the apply closure. */
+declare const sessionPlugin: Plugin.Object<void>;
+export default sessionPlugin;

package/lib/types/session.js

@@ -0,0 +1,76 @@
+/**
+ * The operator session seam: `ctx.session` mirrors the host-side session
+ * (persisted to settings, so a restart keeps the operator signed on) and
+ * re-emits `session/changed` on every transition — its own writes and any
+ * host-side change that rides the `settings/changed` frame. The login page
+ * writes it; every workflow consumer reads it for gating and audit
+ * attribution.
+ *
+ * @module @snap-rail/framework-shadcn/session
+ */
+// Wire rows for the station-domain methods this resident calls.
+import '@snap-rail/station-rpc/contract';
+import { Context } from '@snap-rail/cordis';
+import { subscribeFrame } from '@snap-rail/connection';
+import { SESSION_OPERATOR_KEY, settingsChangedSchema } from '@snap-rail/station-rpc/contract';
+/** Mounts the `ctx.session` mirror; state lives in the apply closure. */
+const sessionPlugin = {
+    name: 'client-session',
+    inject: ['client'],
+    apply(ctx) {
+        const { link } = ctx.client;
+        let operator = null;
+        let restored = false;
+        const sync = (next) => {
+            operator = next;
+            ctx.emit('session/changed', operator);
+        };
+        // Restore the persisted operator; a failed probe leaves the login page
+        // up. The probe races the first rendered frame, so its settlement is
+        // announced on its own event — the login surface holds off until then
+        // instead of flashing the keypad before a restart's operator lands.
+        void link.call('session.current', {})
+            .then(result => {
+            if (result.ok)
+                sync(result.value.operator);
+        })
+            .catch(() => { })
+            .finally(() => {
+            restored = true;
+            ctx.emit('session/restored');
+        });
+        // Hot-follow host-side session changes (another surface signed in or
+        // out — the titlebar's 换人, or the host restarting with a different
+        // persisted operator): re-pull the truth and re-emit on any drift.
+        ctx.effect(() => subscribeFrame(link, 'settings/changed', settingsChangedSchema, change => {
+            if (change.key !== SESSION_OPERATOR_KEY)
+                return;
+            void link.call('session.current', {})
+                .then(result => {
+                if (result.ok && result.value.operator !== operator)
+                    sync(result.value.operator);
+            })
+                .catch(() => { });
+        }));
+        ctx.provide('session', {
+            current: () => operator,
+            restored: () => restored,
+            async login(raw) {
+                const trimmed = raw.trim();
+                if (trimmed === '')
+                    throw new Error('工号不能为空');
+                const result = await link.call('session.login', { operator: trimmed });
+                if (!result.ok)
+                    throw new Error(`登录失败（${result.error.code}）`);
+                sync(trimmed);
+            },
+            async logout() {
+                const result = await link.call('session.logout', {});
+                if (!result.ok)
+                    throw new Error(`退出失败（${result.error.code}）`);
+                sync(null);
+            },
+        });
+    },
+};
+export default sessionPlugin;

package/lib/types/settings-dialog.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The settings dialog shell: a layout occupant that renders nothing until
+ * `ctx.settingsPages` is open, then shows the registered pages as a menu on
+ * the left and the active page's content on the right. Pages come from any
+ * plugin via the settings seam (equipment-station contributes the 设备管理
+ * page that way); the shell itself contributes the first-party plugin
+ * management, theme, and app-update pages — living in the framework bundle
+ * means a framework-only install already manages its own plugins.
+ *
+ * @module @snap-rail/framework-shadcn/settings-dialog
+ */
+import { type Plugin } from '@snap-rail/cordis';
+import './settings-pages.ts';
+import './semantic.tsx';
+/** The settings dialog occupant. */
+declare const settingsDialogPlugin: Plugin.Object<void>;
+export default settingsDialogPlugin;

package/lib/types/settings-dialog.js

@@ -0,0 +1,138 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The settings dialog shell: a layout occupant that renders nothing until
+ * `ctx.settingsPages` is open, then shows the registered pages as a menu on
+ * the left and the active page's content on the right. Pages come from any
+ * plugin via the settings seam (equipment-station contributes the 设备管理
+ * page that way); the shell itself contributes the first-party plugin
+ * management, theme, and app-update pages — living in the framework bundle
+ * means a framework-only install already manages its own plugins.
+ *
+ * @module @snap-rail/framework-shadcn/settings-dialog
+ */
+import { Context } from '@snap-rail/cordis';
+import "./settings-pages.js";
+import { UI_SLOT_IDS } from "./slots.js";
+import "./semantic.js";
+import { subscribeFrame } from '@snap-rail/connection';
+import { settingsChangedSchema } from '@snap-rail/station-rpc/contract';
+import { Button, DragScroll, Tabs, TabsList, TabsTrigger, useRefresh, applyTheme, DEFAULT_THEME, themeSettingsSchema, THEME_SETTINGS_KEY, } from "./ui/index.js";
+import { X } from 'lucide-react';
+import { useEffect, useState } from 'react';
+import { PluginsPage } from "./settings-plugins-page.js";
+import { UpdatePage } from "./settings-update-page.js";
+/** The 主题 settings page: one mode choice (跟随系统/白天/黑夜). The write
+ * hot-applies everywhere via the `settings/changed` frame — no restart. */
+function ThemePage(props) {
+    const [mode, setMode] = useState(props.initial.mode);
+    return (_jsxs("div", { "data-region": "theme-page", className: "flex max-w-xl flex-col gap-4", children: [_jsx("p", { className: "text-sm text-muted-foreground", children: "\u6A21\u5F0F\u7ACB\u5373\u751F\u6548\u5E76\u5199\u5165\u914D\u7F6E\u6587\u4EF6\uFF1B\u8DDF\u968F\u7CFB\u7EDF\u65F6\u968F\u64CD\u4F5C\u7CFB\u7EDF\u7684\u65E5\u591C\u95F4\u8BBE\u7F6E\u81EA\u52A8\u5207\u6362\u3002" }), _jsx(Tabs, { value: mode, onValueChange: next => {
+                    const choice = next;
+                    setMode(choice);
+                    props.onChoose({ mode: choice });
+                }, children: _jsxs(TabsList, { "aria-label": "\u4E3B\u9898\u6A21\u5F0F", children: [_jsx(TabsTrigger, { value: "system", "data-mode-option": "system", children: "\u8DDF\u968F\u7CFB\u7EDF" }), _jsx(TabsTrigger, { value: "light", "data-mode-option": "light", children: "\u767D\u5929" }), _jsx(TabsTrigger, { value: "dark", "data-mode-option": "dark", children: "\u9ED1\u591C" })] }) })] }));
+}
+/** The settings shell: a fullscreen surface that renders the registered
+ * pages as a menu on the left and the active page's content on the right.
+ * Pages come from any plugin via the settings seam; the shell itself
+ * contributes the first-party plugin page (management and market fused)
+ * plus theme and app-update pages. */
+function SettingsDialog({ ctx }) {
+    useRefresh(ctx, ['settings/open-changed', 'settings/pages-changed']);
+    const open = ctx.settingsPages.isOpen();
+    const pages = ctx.settingsPages.list();
+    const activeId = ctx.settingsPages.active();
+    const active = pages.find(page => page.id === activeId);
+    // The shell fills the whole viewport: settings is a surface an operator
+    // lives in, not a modal peek. Escape keeps the dialog-era close gesture.
+    useEffect(() => {
+        if (!open)
+            return;
+        const onKey = (event) => {
+            if (event.key === 'Escape')
+                ctx.settingsPages.close();
+        };
+        window.addEventListener('keydown', onKey);
+        return () => { window.removeEventListener('keydown', onKey); };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [open]);
+    if (!open)
+        return null;
+    return (_jsxs("div", { "data-region": "settings-shell", "data-active-page": activeId, className: "fixed inset-0 z-50 flex flex-col bg-background", children: [_jsxs("div", { className: "flex items-center justify-between border-b border-border px-5 py-3", children: [_jsx("span", { className: "text-lg font-medium", children: "\u8BBE\u7F6E" }), _jsx(Button, { variant: "ghost", size: "icon", "aria-label": "\u5173\u95ED\u8BBE\u7F6E", onClick: () => ctx.settingsPages.close(), children: _jsx(X, { className: "h-5 w-5" }) })] }), _jsxs("div", { className: "flex min-h-0 flex-1", children: [_jsx(DragScroll, { "data-region": "settings-menu", className: "flex w-60 shrink-0 flex-col gap-1 border-r border-border p-2", children: pages.map(page => (_jsx("button", { type: "button", "data-settings-page": page.id, "aria-current": page.active || undefined, className: `flex h-12 w-full items-center rounded-md px-4 text-left text-base transition-colors hover:bg-accent ${page.active ? 'bg-accent font-medium text-accent-foreground channel-keyline' : 'text-muted-foreground'}`, onClick: () => ctx.settingsPages.open(page.id), children: page.title }, page.id))) }), _jsx("div", { "data-region": "settings-content", "data-active-page": activeId, className: "flex min-w-0 flex-1 flex-col overflow-auto p-6", children: active?.render() })] })] }));
+}
+/** The settings dialog occupant. */
+const settingsDialogPlugin = {
+    name: 'framework settings',
+    inject: ['uiContract', 'settingsPages'],
+    apply(ctx) {
+        const client = ctx.get('client');
+        // Theme: apply the stored row (settings.json `ui.theme`) to <html> right
+        // away, keep every surface hot-synced through the settings/changed
+        // frame, and follow the OS preference while in system mode. The page
+        // below is the only writer; its write re-enters through the frame.
+        let theme = DEFAULT_THEME;
+        const adoptTheme = (value) => {
+            const parsed = themeSettingsSchema.safeParse(value);
+            if (!parsed.success)
+                return;
+            theme = parsed.data;
+            applyTheme(document, theme);
+        };
+        applyTheme(document, theme);
+        void client.link.call('settings.get', { key: THEME_SETTINGS_KEY })
+            .then(result => { if (result.ok)
+            adoptTheme(result.value.value); })
+            .catch(() => { });
+        ctx.effect(() => subscribeFrame(client.link, 'settings/changed', settingsChangedSchema, change => {
+            if (change.key === THEME_SETTINGS_KEY)
+                adoptTheme(change.value);
+        }));
+        const osPreference = window.matchMedia('(prefers-color-scheme: light)');
+        ctx.effect(() => {
+            const sync = () => { if (theme.mode === 'system')
+                applyTheme(document, theme); };
+            osPreference.addEventListener('change', sync);
+            return () => { osPreference.removeEventListener('change', sync); };
+        });
+        const chooseTheme = (next) => {
+            theme = next;
+            applyTheme(document, next);
+            void client.link.call('settings.set', { key: THEME_SETTINGS_KEY, value: next });
+        };
+        ctx.settingsPages.register(ctx, {
+            id: 'plugins',
+            title: '插件',
+            order: 0,
+            render() {
+                return _jsx(PluginsPage, { ctx: ctx });
+            },
+        });
+        ctx.settingsPages.register(ctx, {
+            id: 'theme',
+            title: '主题',
+            order: 1,
+            render() {
+                return _jsx(ThemePage, { initial: theme, onChoose: chooseTheme });
+            },
+        });
+        ctx.settingsPages.register(ctx, {
+            id: 'update',
+            title: '软件更新',
+            order: 2,
+            render() {
+                return _jsx(UpdatePage, { ctx: ctx });
+            },
+        });
+        ctx.uiContract.registerLayout(ctx, {
+            // The id is a cross-face contract: the fallback shell excludes
+            // exactly this occupant when deciding whether it is the only
+            // layout — renaming it blanks the fallback.
+            id: 'settings-dialog',
+            order: 100,
+            slots: [UI_SLOT_IDS.overlay],
+            render() {
+                return _jsx(SettingsDialog, { ctx: ctx });
+            },
+        });
+    },
+};
+export default settingsDialogPlugin;

package/lib/types/settings-pages.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The settings seam: `ctx.settingsPages` is a registry of settings-dialog
+ * pages plus the dialog's open state. It knows the mechanism — registration,
+ * ordering, which page is shown, whether the dialog is open — and nothing
+ * about any concrete page. The dialog shell (settings-station) renders the
+ * registry; the chrome's gear button only calls `open()`.
+ *
+ * The service mirrors `ctx.workflows` structurally: register + list plus
+ * change events, with state in construction-time closures.
+ *
+ * @module @snap-rail/framework-shadcn/settings-pages
+ */
+import { Context, type Plugin } from '@snap-rail/cordis';
+import type { ReactNode } from 'react';
+/** What one plugin contributes to the settings dialog. */
+export interface SettingsPageDef {
+    /** Stable page id (the menu and content key). */
+    id: string;
+    /** Menu label. */
+    title: string;
+    /** Menu ordering; ties break by registration time. */
+    order: number;
+    render(): ReactNode;
+}
+/** A settings page as the dialog sees it, with derived state. */
+export interface SettingsPage extends SettingsPageDef {
+    /** Whether this page is the one currently shown. */
+    active: boolean;
+}
+/** Settings registry and dialog state exposed as `ctx.settingsPages`. */
+export interface SettingsPagesService {
+    /** Registered pages in menu order with the active flag. */
+    list(): readonly SettingsPage[];
+    /** Register one page; disposal (caller unload) removes it.
+     * @param caller - owning context; unload drops the page.
+     * @param def - the contribution; same-id re-registration replaces.
+     */
+    register(caller: Context, def: SettingsPageDef): () => void;
+    /** Open the dialog; `id` additionally makes that page active. */
+    open(id?: string): void;
+    /** Close the dialog (the active-page choice is kept). */
+    close(): void;
+    /** Open when closed, close when open. */
+    toggle(): void;
+    /** Whether the dialog is currently open. */
+    isOpen(): boolean;
+    /** The active page id while open — the requested one when registered, else the first menu page; `undefined` while closed. */
+    active(): string | undefined;
+}
+declare module '@snap-rail/cordis' {
+    interface Context {
+        settingsPages: SettingsPagesService;
+    }
+    interface Events {
+        /** The page registry changed (any add, replace, or removal). */
+        'settings/pages-changed'(): void;
+        /** The dialog opened, closed, or switched pages. */
+        'settings/open-changed'(): void;
+    }
+}
+/**
+ * Mounts the `ctx.settingsPages` registry. All state lives in
+ * construction-time closures: traceable context proxies rebind `this` on
+ * every method access, so `this`-reached state cannot back a service here
+ * (the uiSlots lesson).
+ */
+declare const settingsPlugin: Plugin.Object<void>;
+export default settingsPlugin;

package/lib/types/settings-pages.js

@@ -0,0 +1,85 @@
+/**
+ * The settings seam: `ctx.settingsPages` is a registry of settings-dialog
+ * pages plus the dialog's open state. It knows the mechanism — registration,
+ * ordering, which page is shown, whether the dialog is open — and nothing
+ * about any concrete page. The dialog shell (settings-station) renders the
+ * registry; the chrome's gear button only calls `open()`.
+ *
+ * The service mirrors `ctx.workflows` structurally: register + list plus
+ * change events, with state in construction-time closures.
+ *
+ * @module @snap-rail/framework-shadcn/settings-pages
+ */
+import { Context } from '@snap-rail/cordis';
+/**
+ * Mounts the `ctx.settingsPages` registry. All state lives in
+ * construction-time closures: traceable context proxies rebind `this` on
+ * every method access, so `this`-reached state cannot back a service here
+ * (the uiSlots lesson).
+ */
+const settingsPlugin = {
+    name: 'client-settings',
+    apply(ctx) {
+        const pages = new Map();
+        let nextSeq = 0;
+        let open = false;
+        let requestedId;
+        const firstId = () => [...pages.values()]
+            .sort((a, b) => a.def.order - b.def.order || a.seq - b.seq)[0]?.def.id;
+        const activeId = () => {
+            if (!open)
+                return undefined;
+            if (requestedId !== undefined && pages.has(requestedId))
+                return requestedId;
+            return firstId();
+        };
+        const openDialog = (id) => {
+            if (id !== undefined)
+                requestedId = id;
+            if (open && id === undefined)
+                return;
+            open = true;
+            ctx.emit('settings/open-changed');
+        };
+        const closeDialog = () => {
+            if (!open)
+                return;
+            open = false;
+            ctx.emit('settings/open-changed');
+        };
+        ctx.provide('settingsPages', {
+            list() {
+                const current = activeId();
+                return [...pages.values()]
+                    .sort((a, b) => a.def.order - b.def.order || a.seq - b.seq)
+                    .map(({ def }) => ({ ...def, active: def.id === current }));
+            },
+            register(caller, def) {
+                const replaced = pages.has(def.id);
+                pages.set(def.id, { def, seq: nextSeq++ });
+                ctx.emit(replaced ? 'settings/open-changed' : 'settings/pages-changed');
+                const remove = () => {
+                    if (pages.delete(def.id))
+                        ctx.emit('settings/pages-changed');
+                };
+                // Effects take a body producing the disposer; passing `remove`
+                // itself would run it as setup.
+                caller.effect(() => remove);
+                return remove;
+            },
+            open: openDialog,
+            close: closeDialog,
+            toggle() {
+                if (open)
+                    closeDialog();
+                else
+                    openDialog();
+            },
+            isOpen() {
+                return open;
+            },
+            active: activeId,
+        });
+    },
+};
+export default settingsPlugin;

package/lib/types/settings-plugins-page.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The 插件 page — plugin management and discovery fused into one surface. The
+ * top row is a single tri-form input: a local path or an http(s) address
+ * inspects that zip (a plugin, or an offline combo package with `recipe.yml`
+ * at its root; both preview → confirm → install), a dropped file does the
+ * same, anything else searches every configured plugin feed (merged, rows
+ * carry their source). Below, every installed (non-builtin) row lists in
+ * one table — 名称/标识 split into columns, the version cell doubling as
+ * the update affordance (a muted pill normally; a success-colored pill with
+ * a refresh glyph and the feed version when an update is pending — clicking
+ * it updates directly, behind a key-change confirmation when the feed entry
+ * is signed by a different key than the installed copy). The preview shows
+ * the three-state signature verdict per plugin (a combo shows each member's
+ * own verdict — the archive itself is unsigned); an unverified member takes
+ * one extra explicit risk step before it installs. The feed sources hide
+ * behind a small icon button before the input; they default from the app's
+ * shipped `defaults.json` until the user writes their own list. Every write
+ * lands in `plugins.yml`/`settings.json` through the plugins and settings
+ * domains; the files stay the single interface.
+ *
+ * @module @snap-rail/framework-shadcn/settings-plugins-page
+ */
+import '@snap-rail/app-boot/contract';
+import type { Context } from '@snap-rail/cordis';
+import { type ReactNode } from 'react';
+/** The plugins page. */
+export declare function PluginsPage({ ctx }: {
+    ctx: Context;
+}): ReactNode;