@datalayer/core 1.1.66 → 1.2.12

package/lib/state/substates/LayoutState.js

@@ -4,6 +4,7 @@
  */
 import { createStore } from 'zustand/vanilla';
 import { useStore } from 'zustand';
+import { registerSessionState } from '../sessionEnd.js';
 /**
  * Name of the cookie holding the space last selected by the user.
  *
@@ -136,6 +137,17 @@ export const layoutStore = createStore((set, get) => ({
     setScreencapture: (screenCapture) => set((state) => ({ screenCapture })),
     reset: () => set((state) => ({ bootstrapped: false })),
 }));
+// The current space, organization, team and item are the session's own:
+// forgotten when it ends, cookie included.
+registerSessionState({
+    forget: () => {
+        const state = layoutStore.getState();
+        state.updateLayoutSpace(undefined);
+        state.updateLayoutOrganization(undefined);
+        state.updateLayoutTeam(undefined);
+        state.setItem(undefined);
+    },
+});
 export function useLayoutStore(selector) {
     return useStore(layoutStore, selector);
 }

package/lib/state/substates/NavigationState.d.ts

@@ -0,0 +1,82 @@
+/** The signed-in shell: the platform, the business cases, or the admin. */
+export type NavigationView = 'home' | 'agentify' | 'admin';
+/** The shells, and where each one opens when it has not been visited. */
+export declare const NAVIGATION_VIEW_HOMES: Record<NavigationView, string>;
+/** Well-known view identifiers for {@link NavigationState.tabsByView}. */
+export declare const LIBRARY_VIEW = "library";
+export declare const AGENTS_VIEW = "agents";
+export declare const SETTINGS_VIEW = "settings";
+export declare const DATALAYER_VIEW = "datalayer";
+export declare const CONTENTS_VIEW = "contents";
+export declare const TUTOR_VIEW = "tutor";
+export type NavigationState = {
+    /** The shell the reader last chose. */
+    view: NavigationView;
+    /** State which shell is being shown. */
+    setView: (view: NavigationView) => void;
+    /** Swap the platform and the business cases. */
+    toggleView: () => void;
+    /** The page each shell was last on. */
+    lastRouteByView: Partial<Record<NavigationView, string>>;
+    /**
+     * Remember a page as the current shell's, or as another's when told.
+     *
+     * Called by {@link useNavigate} for every navigation, which is what makes
+     * this the one place the answer comes from.
+     */
+    rememberRoute: (route: string, view?: NavigationView) => void;
+    /** Where a shell was left, or where it opens when it never was. */
+    routeForView: (view: NavigationView) => string;
+    /** Last selected tab, by view identifier. */
+    tabsByView: Record<string, string>;
+    /** Keep the tab a view was left on. */
+    setViewTab: (view: string, tab: string) => void;
+    /** The tab a view was left on, if any. */
+    getViewTab: (view: string) => string | undefined;
+    /**
+     * The route a signed-out reader asked for, to resume after signing in.
+     *
+     * Never persisted: a reload must land on the default route, and the OAuth
+     * round trip carries its target in `post_auth_redirect` instead.
+     */
+    requestedRoute?: string;
+    setRequestedRoute: (route: string) => void;
+    clearRequestedRoute: () => void;
+    /** The address the reader was on before the documentation. */
+    docsOrigin?: string;
+    setDocsOrigin: (origin: string) => void;
+};
+/**
+ * Whether a page is worth remembering as a shell's.
+ *
+ * Not the sign-in pages, the OAuth callbacks or the documentation: coming
+ * back to a shell should land on the work, not on the door the reader came
+ * through or on a page that belongs to no shell.
+ */
+export declare function isRememberableRoute(route: string): boolean;
+/**
+ * The shell a route belongs to, read off its first segment.
+ *
+ * The store used to trust whatever `view` said when a route was recorded,
+ * and `view` was only ever written by the header toggle. A reader who
+ * reached Home through a sidebar link while the toggle still said Agentify
+ * had their Home pages filed under Agentify — and the toggle, seeing
+ * "Agentify" already chosen, did nothing when they clicked it.
+ */
+export declare function viewForRoute(route: string): NavigationView;
+export declare const navigationStore: import("zustand").StoreApi<NavigationState>;
+/**
+ * The hook, shaped like a `zustand` store created with `create`: callable
+ * with or without a selector, and carrying `getState`, `setState` and
+ * `subscribe` for the callers — a router guard, a test — that read it outside
+ * a render.
+ */
+export interface UseNavigationStore {
+    (): NavigationState;
+    <T>(selector: (state: NavigationState) => T): T;
+    getState: () => NavigationState;
+    setState: typeof navigationStore.setState;
+    subscribe: typeof navigationStore.subscribe;
+}
+export declare const useNavigationStore: UseNavigationStore;
+export default useNavigationStore;

package/lib/state/substates/NavigationState.js

@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Where the reader is, where they were, and where they left each shell.
+ *
+ * One store for navigation, in core, so every surface reads and writes the
+ * same thing. It answers five questions that used to be four stores in the
+ * landing and a handful of ad-hoc effects:
+ *
+ * - **the shell** — the platform Home, Agentify, or Admin;
+ * - **the page each shell was left on**, so switching shells returns the
+ *   reader to their work rather than to a landing page;
+ *   {@link useNavigate} records it on every navigation;
+ * - **the tab** last chosen in each tabbed view;
+ * - **the route asked for** before signing in, to resume afterwards;
+ * - **the address before the documentation**, for its way back.
+ *
+ * **Where each is kept.** The shell rides in a cookie, so it is sent with
+ * every request and a server render can read it. The shells' last pages and
+ * the tabs are in `localStorage`, which a cookie should not carry. The
+ * requested route and the documentation's origin are memory only, on
+ * purpose: a reload must forget the route asked for before signing in.
+ *
+ * Every read and write goes through the storage in a `try`: a browser that
+ * refuses its storage forgets, and never throws into a render.
+ *
+ * @module state/substates/NavigationState
+ */
+import { useStore } from 'zustand';
+import { createStore } from 'zustand/vanilla';
+import { registerSessionState } from '../sessionEnd.js';
+/** The shells, and where each one opens when it has not been visited. */
+export const NAVIGATION_VIEW_HOMES = {
+    home: '/',
+    agentify: '/agentify',
+    admin: '/admin',
+};
+/** Well-known view identifiers for {@link NavigationState.tabsByView}. */
+export const LIBRARY_VIEW = 'library';
+export const AGENTS_VIEW = 'agents';
+export const SETTINGS_VIEW = 'settings';
+export const DATALAYER_VIEW = 'datalayer';
+export const CONTENTS_VIEW = 'contents';
+export const TUTOR_VIEW = 'tutor';
+/** Where this store is kept, and what the landing kept it under before. */
+const STORAGE_KEY = 'datalayer-navigation';
+const SHELL_COOKIE = 'datalayer-signed-in-view';
+const FORMER_TABS_KEY = 'datalayer_view_tabs';
+/** Days a remembered shell lives in the cookie. */
+const COOKIE_MAX_AGE_DAYS = 365;
+const isView = (value) => value === 'home' || value === 'agentify' || value === 'admin';
+function readCookie(name) {
+    if (typeof document === 'undefined') {
+        return undefined;
+    }
+    const match = document.cookie
+        .split('; ')
+        .find(row => row.startsWith(`${name}=`));
+    return match ? decodeURIComponent(match.slice(name.length + 1)) : undefined;
+}
+function writeCookie(name, value) {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    const maxAge = COOKIE_MAX_AGE_DAYS * 24 * 60 * 60;
+    document.cookie = `${name}=${encodeURIComponent(value)}; path=/; max-age=${maxAge}; SameSite=Lax`;
+}
+function readLocal(name) {
+    try {
+        return globalThis.localStorage?.getItem(name) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * What the last visit left, from the two places it belongs in.
+ *
+ * The shell is taken from the cookie it has always used, so a reader who
+ * chose Agentify before this store existed still finds it. The tabs kept
+ * under the landing's former key are picked up once.
+ */
+function restore() {
+    let persisted = {};
+    const stored = readLocal(STORAGE_KEY);
+    if (stored) {
+        try {
+            const parsed = JSON.parse(stored);
+            // The landing kept this under the same key through zustand's
+            // `persist`, which wraps what it writes in `{ state, version }`.
+            persisted = parsed?.state ?? parsed ?? {};
+        }
+        catch {
+            persisted = {};
+        }
+    }
+    else {
+        const former = readLocal(FORMER_TABS_KEY);
+        if (former) {
+            try {
+                const { state } = JSON.parse(former);
+                persisted = { tabsByView: state?.tabsByView ?? {} };
+            }
+            catch {
+                persisted = {};
+            }
+        }
+    }
+    const shell = readCookie(SHELL_COOKIE);
+    if (isView(shell)) {
+        persisted.view = shell;
+    }
+    return persisted;
+}
+function persist(state) {
+    const written = {
+        view: state.view,
+        lastRouteByView: state.lastRouteByView,
+        tabsByView: state.tabsByView,
+    };
+    try {
+        globalThis.localStorage?.setItem(STORAGE_KEY, JSON.stringify(written));
+    }
+    catch {
+        /* the shells' pages are not remembered */
+    }
+    writeCookie(SHELL_COOKIE, state.view);
+}
+/**
+ * Whether a page is worth remembering as a shell's.
+ *
+ * Not the sign-in pages, the OAuth callbacks or the documentation: coming
+ * back to a shell should land on the work, not on the door the reader came
+ * through or on a page that belongs to no shell.
+ */
+export function isRememberableRoute(route) {
+    if (!route.startsWith('/')) {
+        return false;
+    }
+    const path = route.split('?')[0];
+    return ![
+        '/signin',
+        '/signup',
+        '/login',
+        '/logout',
+        '/oauth2',
+        '/oauth',
+        '/docs',
+        '/join',
+    ].some(prefix => path === prefix || path.startsWith(`${prefix}/`));
+}
+/**
+ * The shell a route belongs to, read off its first segment.
+ *
+ * The store used to trust whatever `view` said when a route was recorded,
+ * and `view` was only ever written by the header toggle. A reader who
+ * reached Home through a sidebar link while the toggle still said Agentify
+ * had their Home pages filed under Agentify — and the toggle, seeing
+ * "Agentify" already chosen, did nothing when they clicked it.
+ */
+export function viewForRoute(route) {
+    const path = route.split('?')[0];
+    if (path === '/agentify' || path.startsWith('/agentify/')) {
+        return 'agentify';
+    }
+    if (path === '/admin' || path.startsWith('/admin/')) {
+        return 'admin';
+    }
+    return 'home';
+}
+const initial = restore();
+export const navigationStore = createStore((set, get) => ({
+    view: initial.view ?? 'home',
+    lastRouteByView: initial.lastRouteByView ?? {},
+    tabsByView: initial.tabsByView ?? {},
+    requestedRoute: undefined,
+    docsOrigin: undefined,
+    setView: view => {
+        set({ view });
+        persist(get());
+    },
+    toggleView: () => {
+        set(state => ({ view: state.view === 'home' ? 'agentify' : 'home' }));
+        persist(get());
+    },
+    rememberRoute: (route, view) => {
+        if (!isRememberableRoute(route)) {
+            return;
+        }
+        // The route says which shell it belongs to; the caller may only insist
+        // when it knows better. And being on a shell's page *is* being in that
+        // shell, so the view follows.
+        const shell = view ?? viewForRoute(route);
+        // Told which shell, the caller is filing a page away, not going there.
+        const follow = view === undefined;
+        const current = get();
+        if (current.lastRouteByView[shell] === route &&
+            (!follow || current.view === shell)) {
+            return;
+        }
+        set(state => ({
+            view: follow ? shell : state.view,
+            lastRouteByView: { ...state.lastRouteByView, [shell]: route },
+        }));
+        persist(get());
+    },
+    routeForView: view => {
+        // Only a page of that shell: an earlier version filed pages under the
+        // shell the toggle named rather than the one the route belonged to, so a
+        // reader can still have `/items` written down as Agentify's page. Going
+        // "to Agentify" must never land on a Home page.
+        const remembered = get().lastRouteByView[view];
+        return remembered && viewForRoute(remembered) === view
+            ? remembered
+            : NAVIGATION_VIEW_HOMES[view];
+    },
+    setViewTab: (view, tab) => {
+        if (get().tabsByView[view] === tab) {
+            return;
+        }
+        set(state => ({ tabsByView: { ...state.tabsByView, [view]: tab } }));
+        persist(get());
+    },
+    getViewTab: view => get().tabsByView[view],
+    setRequestedRoute: route => set({ requestedRoute: route }),
+    clearRequestedRoute: () => set({ requestedRoute: undefined }),
+    setDocsOrigin: origin => set({ docsOrigin: origin }),
+}));
+// The pages each shell was left on, the tabs, the route asked for and the
+// way back from the documentation belong to the person who was signed in:
+// forgotten when the session ends. The shell itself stays — it is the
+// browser's choice of surface, read by the anonymous landing too.
+registerSessionState({
+    forget: () => {
+        navigationStore.setState({
+            lastRouteByView: {},
+            tabsByView: {},
+            requestedRoute: undefined,
+            docsOrigin: undefined,
+        });
+        persist(navigationStore.getState());
+    },
+    localStorageKeys: [FORMER_TABS_KEY],
+});
+function useNavigationState(selector) {
+    return useStore(navigationStore, selector ?? ((state) => state));
+}
+export const useNavigationStore = Object.assign(useNavigationState, {
+    getState: navigationStore.getState,
+    setState: navigationStore.setState,
+    subscribe: navigationStore.subscribe,
+});
+export default useNavigationStore;

package/lib/state/substates/ProfileState.d.ts

@@ -12,6 +12,7 @@ export type IProfile = {
     avatarUrl?: string;
     avatarIcon?: string;
     banner?: string;
+    showOrbits?: boolean;
     origin?: string;
     roles?: string[];
 };

package/lib/state/substates/ProfileState.js

@@ -34,6 +34,7 @@ const userToProfile = (user) => user
         avatarUrl: user.avatarUrl,
         avatarIcon: user.avatarIcon,
         banner: user.banner,
+        showOrbits: user.showOrbits,
         origin: user.origin,
         roles: user.roles,
     }

package/lib/state/substates/index.d.ts

@@ -1,6 +1,7 @@
 export * from './CoreState';
 export * from './IAMState';
 export * from './LayoutState';
+export * from './NavigationState';
 export * from './ProfileState';
 export * from './OrganizationState';
 export * from './SurveysState';

package/lib/state/substates/index.js

@@ -5,6 +5,7 @@
 export * from './CoreState.js';
 export * from './IAMState.js';
 export * from './LayoutState.js';
+export * from './NavigationState.js';
 export * from './ProfileState.js';
 export * from './OrganizationState.js';
 export * from './SurveysState.js';

package/lib/utils/Lazy.d.ts

@@ -2,6 +2,26 @@ import { ComponentType } from 'react';
 export type PreloadableComponent<T extends ComponentType<any>> = T & {
     preload: () => Promise<void>;
 };
+/**
+ * `React.lazy`, with a `preload()` that fetches the module ahead of the
+ * first render.
+ *
+ * Two rules keep it honest:
+ *
+ * - **One fetch.** `preload()` and React's own first render share a single
+ *   call to `factory`. They used to call it separately, so a component that
+ *   was preloaded and then rendered imported its module twice.
+ * - **One element type per mounted instance.** The component renders the
+ *   loaded module directly when it was already loaded at mount — no fallback
+ *   flash — and the lazy wrapper otherwise, and it keeps that choice for its
+ *   lifetime. It used to switch from the wrapper to the loaded module on any
+ *   render after `preload()` resolved, and React remounts on a change of
+ *   element type: a component preloaded after it had mounted lost its state
+ *   and ran its effects again on its next render.
+ *
+ * A failed fetch is forgotten, so the next `preload()` tries again rather
+ * than replaying the failure.
+ */
 export declare function lazyWithPreload<T extends ComponentType<any>>(factory: () => Promise<{
     default: T;
 }>): PreloadableComponent<T>;

package/lib/utils/Lazy.js

@@ -2,22 +2,48 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import { createElement, forwardRef, lazy as reactLazy, } from 'react';
+import { createElement, forwardRef, lazy as reactLazy, useState, } from 'react';
+/**
+ * `React.lazy`, with a `preload()` that fetches the module ahead of the
+ * first render.
+ *
+ * Two rules keep it honest:
+ *
+ * - **One fetch.** `preload()` and React's own first render share a single
+ *   call to `factory`. They used to call it separately, so a component that
+ *   was preloaded and then rendered imported its module twice.
+ * - **One element type per mounted instance.** The component renders the
+ *   loaded module directly when it was already loaded at mount — no fallback
+ *   flash — and the lazy wrapper otherwise, and it keeps that choice for its
+ *   lifetime. It used to switch from the wrapper to the loaded module on any
+ *   render after `preload()` resolved, and React remounts on a change of
+ *   element type: a component preloaded after it had mounted lost its state
+ *   and ran its effects again on its next render.
+ *
+ * A failed fetch is forgotten, so the next `preload()` tries again rather
+ * than replaying the failure.
+ */
 export function lazyWithPreload(factory) {
-    const LazyComponent = reactLazy(factory);
     let factoryPromise;
     let LoadedComponent;
-    const Component = forwardRef(function LazyWithPreload(props, ref) {
-        return createElement(LoadedComponent ?? LazyComponent, Object.assign(ref ? { ref } : {}, props));
-    });
-    Component.preload = () => {
+    const load = () => {
         if (!factoryPromise) {
             factoryPromise = factory().then(module => {
                 LoadedComponent = module.default;
+                return module;
+            }, error => {
+                factoryPromise = undefined;
+                throw error;
             });
         }
         return factoryPromise;
     };
+    const LazyComponent = reactLazy(load);
+    const Component = forwardRef(function LazyWithPreload(props, ref) {
+        const [Resolved] = useState(() => LoadedComponent ?? LazyComponent);
+        return createElement(Resolved, Object.assign(ref ? { ref } : {}, props));
+    });
+    Component.preload = () => load().then(() => undefined);
     return Component;
 }
 export default lazyWithPreload;

package/lib/utils/Screencapture.d.ts

@@ -1 +1,16 @@
+/**
+ * A picture of one rendered node, as a PNG data URL.
+ *
+ * This used `html2canvas`, which does not capture a node: it clones the
+ * **whole document** into a hidden iframe and paints all of it, then crops.
+ * On a rendered notebook that is every cell, every editor and every output,
+ * and the clone is synchronous — the page froze for ten seconds or more with
+ * the share dialog saying "preparing…", which reads as a hang, and on a
+ * longer notebook it was one. `html-to-image` serialises the node's own
+ * subtree into an SVG `foreignObject` and rasterises that: the work is
+ * proportional to the output being shared, and it yields to the page.
+ *
+ * Cross-origin pictures are fetched for the clone, as before, so a cell
+ * carrying an `<img>` from the web does not capture as a blank rectangle.
+ */
 export declare const takeHTMLNodeScreencapture: (node: HTMLDivElement) => Promise<string>;

package/lib/utils/Screencapture.js

@@ -2,26 +2,32 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import html2canvas from 'html2canvas';
+import { toPng } from 'html-to-image';
+/**
+ * A picture of one rendered node, as a PNG data URL.
+ *
+ * This used `html2canvas`, which does not capture a node: it clones the
+ * **whole document** into a hidden iframe and paints all of it, then crops.
+ * On a rendered notebook that is every cell, every editor and every output,
+ * and the clone is synchronous — the page froze for ten seconds or more with
+ * the share dialog saying "preparing…", which reads as a hang, and on a
+ * longer notebook it was one. `html-to-image` serialises the node's own
+ * subtree into an SVG `foreignObject` and rasterises that: the work is
+ * proportional to the output being shared, and it yields to the page.
+ *
+ * Cross-origin pictures are fetched for the clone, as before, so a cell
+ * carrying an `<img>` from the web does not capture as a blank rectangle.
+ */
 export const takeHTMLNodeScreencapture = async (node) => {
-    const sc = html2canvas(node, {
-        width: node.getBoundingClientRect().width,
-        height: node.getBoundingClientRect().height,
-    });
-    return sc.then(canvas => {
-        const croppedCanvas = document.createElement('canvas');
-        const croppedCanvasContext = croppedCanvas.getContext('2d');
-        const top = 0;
-        const left = 0;
-        const width = canvas.width;
-        const height = canvas.height;
-        croppedCanvas.width = width;
-        croppedCanvas.height = height;
-        croppedCanvasContext?.drawImage(canvas, left, top, width, height, left, top, width, height);
-        //    const type = 'image/jpeg';
-        const type = 'image/png';
-        const quality = 1;
-        const outputshotData = croppedCanvas.toDataURL(type, quality);
-        return outputshotData;
+    const { backgroundColor } = getComputedStyle(node);
+    return toPng(node, {
+        // Crisp on a dense display, still a modest file for a text output.
+        pixelRatio: Math.min(window.devicePixelRatio || 1, 2),
+        // Outputs are usually transparent over the page's canvas: give the
+        // picture that canvas rather than a transparent one.
+        backgroundColor: backgroundColor && backgroundColor !== 'rgba(0, 0, 0, 0)'
+            ? backgroundColor
+            : getComputedStyle(document.body).backgroundColor || '#ffffff',
+        cacheBust: true,
     });
 };

package/lib/utils/WithSuspense.d.ts

@@ -1,2 +1,12 @@
-export declare const WithSuspense: (Component: any, preload?: boolean, skeleton?: boolean) => (props: any) => import("react").JSX.Element;
+import { type ReactNode } from 'react';
+/**
+ * A lazily-loaded route, with something to look at while it arrives.
+ *
+ * `skeleton` was a boolean between one grey box and **nothing at all**, and
+ * nothing was the default — so every route in the application showed a blank
+ * page for as long as its chunk took, which for an editor is seconds. It now
+ * also takes a node, so a route can hand over a drawing of the thing that is
+ * coming rather than a hole where it will be.
+ */
+export declare const WithSuspense: (Component: any, preload?: boolean, skeleton?: boolean | ReactNode) => (props: any) => import("react").JSX.Element;
 export default WithSuspense;

package/lib/utils/WithSuspense.js

@@ -9,10 +9,20 @@ const Loading = (props) => {
     const { skeleton } = props;
     return skeleton ? (_jsx(_Fragment, { children: _jsx(SkeletonBox, { height: "100px" }) })) : (_jsx(_Fragment, {}));
 };
+/**
+ * A lazily-loaded route, with something to look at while it arrives.
+ *
+ * `skeleton` was a boolean between one grey box and **nothing at all**, and
+ * nothing was the default — so every route in the application showed a blank
+ * page for as long as its chunk took, which for an editor is seconds. It now
+ * also takes a node, so a route can hand over a drawing of the thing that is
+ * coming rather than a hole where it will be.
+ */
 export const WithSuspense = (Component, preload = true, skeleton = false) => (props) => {
     if (preload) {
         Component.preload();
     }
-    return (_jsx(Suspense, { fallback: _jsx(Loading, { skeleton: skeleton }), children: _jsx(Component, { ...props }) }));
+    const fallback = typeof skeleton === 'boolean' ? (_jsx(Loading, { skeleton: skeleton })) : (skeleton);
+    return (_jsx(Suspense, { fallback: fallback, children: _jsx(Component, { ...props }) }));
 };
 export default WithSuspense;

package/lib/views/mcp/AdmittedClients.d.ts

@@ -0,0 +1,44 @@
+/**
+ * What the admitted-clients list actually admits.
+ *
+ * The field above it is a textarea of client ids, because that is what they
+ * are: a client id is a URL somebody pastes, and there is nothing to pick
+ * from. What a textarea cannot do is tell whoever typed it whether an entry
+ * resolves — and this is the one policy rule whose typo fails silently in
+ * the direction that matters. A misspelled entry does not refuse anything
+ * loudly; it never matches, and every agent from that vendor is turned away
+ * with "your organization does not admit this client", which reads to its
+ * owner as a decision somebody made on purpose.
+ *
+ * So each stored entry is shown with what it names. Three states, and the
+ * reason this is a component rather than a line of text is that collapsing
+ * any two of them misleads:
+ *
+ * * a **hostname** admits every client that host publishes. There is no
+ *   document and none is expected — shown as unresolved it would send
+ *   somebody chasing a fetch that was never going to happen.
+ * * a **document that resolves**, with the name and publishing host.
+ * * a **document that does not**, with the reason. The state the whole
+ *   thing is for.
+ *
+ * **It describes what is stored, not the draft.** Resolving on every
+ * keystroke would make a textarea a source of outbound requests, so this
+ * goes stale while somebody edits and says so rather than pretending to
+ * describe a line that has not been saved.
+ *
+ * @module views/mcp/AdmittedClients
+ */
+import type { JSX } from 'react';
+import type { McpPolicyScope } from '../../api/iam/mcpPolicy';
+export interface AdmittedClientsProps {
+    scope: McpPolicyScope;
+    subjectUid: string;
+    /**
+     * Whether the textarea above differs from what is stored. The entries
+     * below describe the *stored* list, and saying so is the difference
+     * between a stale panel and a wrong one.
+     */
+    edited?: boolean;
+}
+export declare const AdmittedClients: ({ scope, subjectUid, edited, }: AdmittedClientsProps) => JSX.Element | null;
+export default AdmittedClients;