@datalayer/agent-runtimes 1.0.29 → 1.3.11

package/lib/loop/plugins/page-layout/index.js

@@ -0,0 +1,160 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CommentDiscussionIcon } from '@primer/octicons-react';
+import { definePlugin, signal } from '@datalayer/reactor';
+import { useContributions, useSignalValue } from '@datalayer/reactor/react';
+import { PageLayout, PagePanelToggle, openPagePanel, } from '@datalayer/primer-addons/lib/reactor';
+import { ChatViewModeToggle } from '../../../chat/header/ChatViewModeToggle';
+import { LoopChatLayout, LoopChatTurn, LoopPromptPanel, LoopSlots, } from '../../core';
+import { TurnPanel } from './TurnPanel';
+/*
+ * The layout's state is primer-addons', re-exported under the names the
+ * Loop always had: a host that opened the conversation panel by calling
+ * `openConversationPanel()` keeps doing so.
+ */
+export { pageLayoutPanelOpen, pageLayoutSheet, openPagePanel as openConversationPanel, } from '@datalayer/primer-addons/lib/reactor';
+export const LOOP_PAGE_LAYOUT_PLUGIN_NAME = '@datalayer/loop-plugin-page-layout';
+/* A signal to read when no chat contributed a turn: the hook needs one. */
+const NO_TURN = signal({ id: 0, status: 'idle' });
+/**
+ * How the page layout shows the chat, when the composer is the floating
+ * card: the card itself over the page (`floating-draggable`, where it
+ * starts), or the conversation panel with the composer standing in it —
+ * beside the page (`sidebar`), over its right edge at full height
+ * (`floating`), or as a window in its corner (`floating-small`). The four
+ * modes of the chat header's toggle, which the card carries in its own
+ * footer. One signal for the workspace, as `pageLayoutPanelOpen` is: the
+ * mode is the person's, not a build's.
+ */
+export const pageLayoutChatMode = signal('floating-draggable');
+/** The composer's stance for the chat view, following the mode above. */
+const promptStance = signal('floating-top');
+/*
+ * Which edge the card returns to when the mode puts it back over the page:
+ * the build's own `promptAnchor`, kept here because the mode is picked
+ * through a module-level function, as `pageLayoutChatMode` itself is. One
+ * page layout to a page, the assumption that signal already makes.
+ */
+let floatingStance = 'floating-top';
+export function pageLayoutForChatMode(mode) {
+    switch (mode) {
+        case 'sidebar':
+            return { bandMode: 'panel', panelMode: 'docked' };
+        case 'floating':
+            return { bandMode: 'panel', panelMode: 'overlay' };
+        case 'floating-small':
+            return { bandMode: 'panel', panelMode: 'popup' };
+        default:
+            return { bandMode: 'floating', panelMode: 'docked' };
+    }
+}
+/** Picks a mode: the layout follows, and so does the composer's stance. */
+export function setPageLayoutChatMode(mode) {
+    pageLayoutChatMode.value = mode;
+    const { bandMode } = pageLayoutForChatMode(mode);
+    promptStance.value = bandMode === 'floating' ? floatingStance : 'docked-top';
+    // The composer went into the panel: the panel opens to show it.
+    if (bandMode === 'panel') {
+        openPagePanel();
+    }
+}
+/** The toggle in the floating composer's footer. */
+function ChatModeAction() {
+    const mode = useSignalValue(pageLayoutChatMode);
+    return _jsx(ChatViewModeToggle, { value: mode, onChange: setPageLayoutChatMode });
+}
+/**
+ * The chat view's parts on the page layout.
+ *
+ * The editors are the page, the transcript the panel, the composer the band;
+ * what the agent is doing — the turn's `activity` — is the line at the top
+ * of the sheet, so the change is seen where it happens.
+ */
+function LoopPageLayout({ parts, promptMode, pageSize, }) {
+    const turnEntries = useContributions(LoopChatTurn);
+    const turn = useSignalValue(turnEntries[0]?.value.turn ?? NO_TURN);
+    const chatMode = useSignalValue(pageLayoutChatMode);
+    // The display modes are the floating card's own; a docked composer stays
+    // docked above the page, whatever mode was picked elsewhere.
+    const placement = promptMode === 'floating'
+        ? pageLayoutForChatMode(chatMode)
+        : { bandMode: 'docked', panelMode: 'docked' };
+    return (_jsx(PageLayout, { page: parts.editors, hasPage: parts.hasEditor, panel: parts.transcript, band: parts.prompt, chips: parts.chips, picker: parts.picker, transient: parts.transient, activity: turn.activity, bandMode: placement.bandMode, panelMode: placement.panelMode, pageSize: pageSize }));
+}
+/** The header button that opens and closes the conversation panel. */
+function ConversationToggle() {
+    return (_jsx(PagePanelToggle, { panelName: "conversation", icon: CommentDiscussionIcon, sx: { order: 2 } }));
+}
+export const LoopPageLayoutPlugin = definePlugin({
+    name: LOOP_PAGE_LAYOUT_PLUGIN_NAME,
+    config: {
+        turnPanel: 'below',
+        turnPanelFooter: 'full',
+        prompt: 'docked',
+        promptAnchor: 'top',
+        pageSize: undefined,
+    },
+    displayName: 'Page layout',
+    description: 'The editor — or, in the chat view, the conversation — on a centred sheet, the prompt docked above it at the same width or floating over it as a draggable card, the current turn under the prompt, the conversation in a side panel.',
+    octicon: 'file',
+    emoji: '\u{1F4C4}',
+    build: ({ config, ...ctx }) => {
+        /*
+          The layout, contributed per build because the composer's stance is
+          configuration: `docked-top` means the layout owns the composer's width
+          — `PageLayout` gives it a mount point the width of the sheet, so the
+          prompt and the page read as one column; `floating-top` and
+          `floating-bottom` are the draggable
+          card, sized by itself, over a strip of canvas kept clear for it. The
+          component closes over the choice once, per build.
+        */
+        const promptMode = config.prompt;
+        const pageSize = config.pageSize;
+        floatingStance =
+            config.promptAnchor === 'bottom' ? 'floating-bottom' : 'floating-top';
+        if (promptMode === 'floating') {
+            promptStance.value = floatingStance;
+        }
+        const ConfiguredLayout = (parts) => (_jsx(LoopPageLayout, { parts: parts, promptMode: promptMode, pageSize: pageSize }));
+        ctx.contribute(LoopChatLayout, {
+            id: 'page-layout',
+            prompt: promptMode === 'floating' ? floatingStance : 'docked-top',
+            // Live only for the card: its display modes move the composer.
+            promptStance: promptMode === 'floating' ? promptStance : undefined,
+            Component: ConfiguredLayout,
+        }, { id: 'page-layout' });
+        // The turn panel is configuration-dependent, so it is contributed here
+        // rather than statically: which side, what footer, or not at all. The
+        // component closes over the footer choice once, per build.
+        if (config.turnPanel !== 'none') {
+            const footer = config.turnPanelFooter;
+            const ConfiguredTurnPanel = () => (_jsx(TurnPanel, { footer: footer }));
+            ctx.contribute(LoopPromptPanel, {
+                id: 'page-layout-turn',
+                placement: config.turnPanel,
+                order: 0,
+                Component: ConfiguredTurnPanel,
+            }, { id: 'page-layout-turn' });
+        }
+        return {
+            components: [
+                {
+                    id: 'page-layout-conversation-toggle',
+                    slot: LoopSlots.header,
+                    Component: ConversationToggle,
+                },
+                // The display modes, in the floating card's footer — and only
+                // there: a docked composer has none to pick.
+                ...(promptMode === 'floating'
+                    ? [
+                        {
+                            id: 'page-layout-chat-mode',
+                            slot: LoopSlots.promptAction,
+                            Component: ChatModeAction,
+                        },
+                    ]
+                    : []),
+            ],
+        };
+    },
+});
+export default LoopPageLayoutPlugin;

package/lib/loop/plugins/plugins-panel/index.d.ts

@@ -0,0 +1,14 @@
+import type { ReactorReactOutput } from '@datalayer/reactor/react';
+export declare const PLUGINS_PANEL_PLUGIN_NAME = "@datalayer/loop-plugin-plugins-panel";
+/**
+ * How wide the panel is, and the aside around it.
+ *
+ * Declared here rather than in the shell so the two cannot disagree: the panel
+ * truncates its descriptions to the width it was given, and truncating to a
+ * width the container does not actually have is how text ends up cut short in
+ * the middle of empty space.
+ */
+export declare const SIDEBAR_WIDTH = 420;
+export declare const PluginsPanelPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, ReactorReactOutput>;
+export { PluginsManagerView as PluginsPanel } from '@datalayer/reactor-manager';
+export default PluginsPanelPlugin;

package/lib/loop/plugins/plugins-panel/index.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-plugins-panel` — the plugin list, as a plugin.
+ *
+ * It fills the sidebar slot like any other contribution, which is the joke and
+ * also the proof: the thing that switches plugins on and off is itself one, and
+ * can be left out of a host that does not want it.
+ *
+ * The list itself is no longer written here. `@datalayer/reactor-manager` is
+ * the same surface, generic — a filter, a row per plugin, a switch each — and
+ * the workspace had grown its own copy that answered the same questions
+ * slightly differently. This plugin is now the loop's placement of it: which
+ * slot it goes in, and which plugin may not be switched off.
+ *
+ * What went with the rewrite is the graph button. The panel used to draw it,
+ * which meant asking by name whether a graph view was mounted; the graph
+ * plugin contributes it to the manager's action slot now, so it appears and
+ * disappears with the thing it opens.
+ *
+ * @module loop/plugins/plugins-panel
+ */
+import { definePlugin } from '@datalayer/reactor';
+import { GraphPlugin } from '@datalayer/reactor-graph';
+import { PluginsManagerView } from '@datalayer/reactor-manager';
+import { LoopSlots } from '../../core';
+export const PLUGINS_PANEL_PLUGIN_NAME = '@datalayer/loop-plugin-plugins-panel';
+/**
+ * How wide the panel is, and the aside around it.
+ *
+ * Declared here rather than in the shell so the two cannot disagree: the panel
+ * truncates its descriptions to the width it was given, and truncating to a
+ * width the container does not actually have is how text ends up cut short in
+ * the middle of empty space.
+ */
+export const SIDEBAR_WIDTH = 420;
+/** The generic graph plugin, which the loop's own adapter wraps. */
+const REACTOR_GRAPH_PLUGIN_NAME = GraphPlugin.name;
+export const PluginsPanelPlugin = definePlugin({
+    name: PLUGINS_PANEL_PLUGIN_NAME,
+    displayName: 'Plugins panel',
+    description: 'Switch plugins on and off while the workspace runs.',
+    octicon: 'plug',
+    emoji: '\u{1F50C}',
+    build: () => ({
+        components: [
+            {
+                id: 'plugins-panel',
+                slot: LoopSlots.sidebar,
+                // Last in the sidebar: it is about the workspace rather than part of
+                // the work, so a plugin's own panel — the decks list, say — sits
+                // above it whatever order the plugins were listed in.
+                order: 900,
+                // Itself protected: switching the panel off would remove the only way
+                // to switch anything back on.
+                //
+                // The workspace is forwarded rather than used here — the manager
+                // passes whatever it is given to the plugins contributing actions, and
+                // the graph button is the one that needs it.
+                Component: ({ workspace }) => (_jsx(PluginsManagerView, { protectedPlugins: [PLUGINS_PANEL_PLUGIN_NAME], 
+                    // `@datalayer/loop-plugin-graph` is the switch that matters: it
+                    // places the graph in this workspace and pulls the generic plugin
+                    // in as a dependency. Listing both put two switches in front of
+                    // one feature, with no way to tell which to use.
+                    hiddenPlugins: [REACTOR_GRAPH_PLUGIN_NAME], width: SIDEBAR_WIDTH, workspace: workspace })),
+            },
+        ],
+    }),
+});
+export { PluginsManagerView as PluginsPanel } from '@datalayer/reactor-manager';
+export default PluginsPanelPlugin;

package/lib/loop/plugins/prompt/NewChatAction.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The + in the prompt's footer: start the conversation over.
+ *
+ * The chat header carries the same control, and a workspace that hides that
+ * header — the Loop Shell does — used to lose the only way to reset. This one
+ * lives with the composer, which is on screen in every placement.
+ *
+ * It presses the `/new` command rather than reaching into the chat, so the
+ * button and the slash command cannot drift: one intent, one path, and the
+ * command's own error shows when no conversation is on screen.
+ *
+ * @module loop/plugins/prompt/NewChatAction
+ */
+import type { JSX } from 'react';
+import type { LoopWorkspaceContext } from '../../core';
+export declare function NewChatAction({ workspace, }: {
+    workspace?: LoopWorkspaceContext;
+}): JSX.Element | null;
+export default NewChatAction;

package/lib/loop/plugins/prompt/NewChatAction.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { IconButton } from '@primer/react';
+import { PlusIcon } from '@primer/octicons-react';
+export function NewChatAction({ workspace, }) {
+    if (!workspace) {
+        return null;
+    }
+    return (_jsx(IconButton, { icon: PlusIcon, "aria-label": "New conversation", title: "New conversation", variant: "invisible", size: "small", onClick: () => void workspace.submit('/new') }));
+}
+export default NewChatAction;

package/lib/loop/plugins/prompt/index.d.ts

@@ -0,0 +1,11 @@
+import { NewChatAction } from './NewChatAction';
+export declare const PROMPT_PLUGIN_NAME = "@datalayer/loop-plugin-prompt";
+export declare const PromptPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, {
+    components: {
+        id: string;
+        slot: "loop.promptAction";
+        Component: typeof NewChatAction;
+    }[];
+}>;
+export { focusPrompt, onPromptFocusRequest } from '../../core';
+export default PromptPlugin;

package/lib/loop/plugins/prompt/index.js

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-prompt` — the prompt as a first-class subject.
+ *
+ * The composer itself is the chat's, whatever the placement: docked under the
+ * workspace, in the chat column, or floating in a draggable card
+ * (`promptPlacement: 'floating'` on the chat, which is the real
+ * `InputPrompt` — lexical editor, slash commands, the tools/skills/model
+ * footer — wrapped in `FloatingCard`). This plugin deliberately ships no
+ * second input box: two composers for one conversation is one too many, and a
+ * reimplementation would be a composer that drifts.
+ *
+ * What it adds is around the composer: `/prompt` (Mod+Alt+P) puts the caret
+ * in it from anywhere, through the same ask-and-answer channel the editor
+ * commands use; `/new` (Mod+Alt+R) starts the conversation over, and the +
+ * this plugin puts in the prompt's footer bar presses exactly that command.
+ * `loopPlugins({ floatingPrompt: true })` mounts this plugin and asks the
+ * chat for the floating placement together.
+ *
+ * @module loop/plugins/prompt
+ */
+import { contribution, definePlugin } from '@datalayer/reactor';
+import { LoopCommand, LoopSlots, focusPrompt } from '../../core';
+import { NewChatAction } from './NewChatAction';
+export const PROMPT_PLUGIN_NAME = '@datalayer/loop-plugin-prompt';
+export const PromptPlugin = definePlugin({
+    name: PROMPT_PLUGIN_NAME,
+    displayName: 'Prompt',
+    description: 'Prompt commands: focus the composer, start over, and the +.',
+    octicon: 'paper-airplane',
+    emoji: '\u{1FAB6}',
+    contributes: [
+        contribution(LoopCommand, {
+            name: 'prompt',
+            description: 'Focus the prompt',
+            group: 'Session',
+            keybinding: 'Mod+Alt+P',
+            run: async () => {
+                if (!focusPrompt()) {
+                    throw new Error('No prompt is on screen to focus.');
+                }
+            },
+        }, { id: 'prompt' }),
+        contribution(LoopCommand, {
+            name: 'new',
+            aliases: ['reset'],
+            description: 'Start the conversation over',
+            group: 'Session',
+            keybinding: 'Mod+Alt+R',
+            run: async ({ workspace }) => {
+                const reset = workspace.viewControls.newChat;
+                if (!reset) {
+                    throw new Error('No conversation is on screen to start over.');
+                }
+                reset();
+            },
+        }, { id: 'new' }),
+    ],
+    build: () => ({
+        components: [
+            {
+                id: 'new-chat',
+                slot: LoopSlots.promptAction,
+                Component: NewChatAction,
+            },
+        ],
+    }),
+});
+export { focusPrompt, onPromptFocusRequest } from '../../core';
+export default PromptPlugin;

package/lib/loop/plugins/shell/editorChoice.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The editor choice, in the loop's vocabulary.
+ *
+ * The store itself lives in `@datalayer/reactor-shell` now — the loop's
+ * editor selector grew into the generic shell plugin, and this module is the
+ * thin dictionary between the two: `editor` here is `view` there. Kept so
+ * everything written against the loop's names (the `/editor` command, the
+ * tests, the barrel) reads unchanged.
+ *
+ * The one behavioural difference from the old local store is deliberate:
+ * `chooseEditor` no longer calls the chat's surface channel itself — the
+ * generic store announces every choice through the announcer the loop's
+ * shell plugin installs, which is wired to `requestSurface`. One path,
+ * whether the choice came from the selector, `/editor`, or the generic
+ * cycle command.
+ *
+ * @module loop/plugins/shell/editorChoice
+ */
+import { chooseView, nextView, seedViewChoice, setViewOptions, subscribeViewChoice } from '@datalayer/reactor-shell';
+/** The choice that means "just the conversation". */
+export declare const NONE_EDITOR = "none";
+/** The current request and options, in loop names. */
+export declare function getEditorChoice(): {
+    editorId: string;
+    options: readonly string[];
+};
+export declare const subscribeEditorChoice: typeof subscribeViewChoice;
+export declare const setEditorOptions: typeof setViewOptions;
+export declare const chooseEditor: typeof chooseView;
+export declare const seedEditorChoice: typeof seedViewChoice;
+export declare const nextEditor: typeof nextView;

package/lib/loop/plugins/shell/editorChoice.js

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The editor choice, in the loop's vocabulary.
+ *
+ * The store itself lives in `@datalayer/reactor-shell` now — the loop's
+ * editor selector grew into the generic shell plugin, and this module is the
+ * thin dictionary between the two: `editor` here is `view` there. Kept so
+ * everything written against the loop's names (the `/editor` command, the
+ * tests, the barrel) reads unchanged.
+ *
+ * The one behavioural difference from the old local store is deliberate:
+ * `chooseEditor` no longer calls the chat's surface channel itself — the
+ * generic store announces every choice through the announcer the loop's
+ * shell plugin installs, which is wired to `requestSurface`. One path,
+ * whether the choice came from the selector, `/editor`, or the generic
+ * cycle command.
+ *
+ * @module loop/plugins/shell/editorChoice
+ */
+import { NONE_VIEW, chooseView, getViewChoice, nextView, seedViewChoice, setViewAnnouncer, setViewOptions, subscribeViewChoice, } from '@datalayer/reactor-shell';
+import { requestSurface } from '../../core/surfaceRequests';
+/*
+ * Wired at import, not only at plugin start: the `/editor` command is a
+ * plain contribution that can be run without a reactor around it — the tests
+ * do, and so does anything driving commands headlessly — and a choice that
+ * silently announced to nobody would look exactly like the bug the surface
+ * channel exists to prevent. The loop shell plugin installs the same
+ * announcer again when it registers, which is idempotent by construction.
+ */
+setViewAnnouncer(requestSurface);
+/** The choice that means "just the conversation". */
+export const NONE_EDITOR = NONE_VIEW;
+/*
+ * Cached per underlying state: `useSyncExternalStore` re-renders whenever
+ * the snapshot's identity changes, so a getter that builds a fresh object on
+ * every call is an infinite render loop waiting for its first subscriber —
+ * the view-switch icons found it. The store replaces its state object only
+ * on actual change, which makes it the perfect cache key.
+ */
+let mappedFor = null;
+let mapped = null;
+/** The current request and options, in loop names. */
+export function getEditorChoice() {
+    const state = getViewChoice();
+    if (state !== mappedFor || !mapped) {
+        mappedFor = state;
+        mapped = { editorId: state.viewId, options: state.options };
+    }
+    return mapped;
+}
+export const subscribeEditorChoice = subscribeViewChoice;
+export const setEditorOptions = setViewOptions;
+export const chooseEditor = chooseView;
+export const seedEditorChoice = seedViewChoice;
+export const nextEditor = nextView;

package/lib/loop/plugins/shell/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * `@datalayer/loop-plugin-shell` — the loop's face of the generic shell.
+ *
+ * The machinery lives in `@datalayer/reactor-shell` now: the view choice
+ * store, the segmented selector that shows nothing until plugins contribute,
+ * the cycle command. This plugin is what makes it *the loop's*:
+ *
+ * - it points the generic plugin at {@link LoopEditorView} — the editor
+ *   point the notebook and document fill — and declares the loop's points;
+ * - it teaches the selector to read a {@link ChatSurfaceContribution},
+ *   gating against the live workspace the header slot passes;
+ * - it wires the announcer to `requestSurface`, so a choice reaches the chat
+ *   through the same channel `/notebook` and `/document` use;
+ * - it keeps the `/editor` slash command, in the loop's own registry.
+ *
+ * @module loop/plugins/shell
+ */
+import type { JSX } from 'react';
+export declare const SHELL_PLUGIN_NAME = "@datalayer/loop-plugin-shell";
+export type ShellPluginConfig = {
+    /**
+     * The editor the selector starts on.
+     *
+     * A preference, not a demand, exactly like the chat's `defaultSurface` — a
+     * named editor whose plugin is not mounted leaves the selector on `'none'`.
+     * The two configs should agree; `loopPlugins` sets both from one option.
+     */
+    defaultEditor: string;
+    /**
+     * Whether the header carries the segmented control at all.
+     *
+     * The points are declared either way — extending the shell must not
+     * depend on whether its selector happens to be drawn.
+     */
+    showSelector: boolean;
+};
+/** The generic selector, dressed for the loop's header. */
+declare function EditorSelectorComponent(slotProps: Record<string, unknown>): JSX.Element | null;
+export declare const ShellPlugin: import("@datalayer/reactor").ReactorPlugin<ShellPluginConfig, unknown, unknown>;
+export { NONE_EDITOR, chooseEditor, getEditorChoice, nextEditor, seedEditorChoice, setEditorOptions, subscribeEditorChoice, } from './editorChoice';
+/** The loop's selector, for a host that renders it somewhere of its own. */
+export { EditorSelectorComponent as EditorSelector };
+/** @deprecated The editors plugin grew into the shell plugin; same object. */
+export declare const EditorsPlugin: import("@datalayer/reactor").ReactorPlugin<ShellPluginConfig, unknown, unknown>;
+/** @deprecated See {@link SHELL_PLUGIN_NAME}. */
+export declare const EDITORS_PLUGIN_NAME = "@datalayer/loop-plugin-shell";
+export default ShellPlugin;

package/lib/loop/plugins/shell/index.js

@@ -0,0 +1,142 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { configurePlugin, contribution, definePlugin, } from '@datalayer/reactor';
+import { ShellPlugin as ReactorShellPlugin, ViewSelector, } from '@datalayer/reactor-shell';
+import { LoopCommand, LoopEditorView, LoopSlots, LoopViewType, canOpenView, requestSurface, } from '../../core';
+import { NONE_EDITOR, chooseEditor, getEditorChoice, nextEditor, seedEditorChoice, } from './editorChoice';
+import { useEditorPreviews } from './useEditorPreviews';
+export const SHELL_PLUGIN_NAME = '@datalayer/loop-plugin-shell';
+/** How a loop editor contribution reads as the generic selector's view. */
+function describeEditor(value, context) {
+    const surface = value;
+    const workspace = context
+        ?.workspace;
+    const openable = workspace ? canOpenView(surface, workspace) : true;
+    return {
+        id: surface.surfaceId,
+        title: surface.title,
+        icon: surface.icon,
+        order: surface.order,
+        disabled: !openable,
+        disabledReason: openable
+            ? undefined
+            : (workspace && surface.unavailableReason?.(workspace)) ||
+                'Not available right now',
+    };
+}
+/** The generic selector, dressed for the loop's header. */
+function EditorSelectorComponent(slotProps) {
+    const workspace = slotProps
+        .workspace;
+    /*
+     * Live figures for the labels — "Notebook (4)" — and the hover cards
+     * behind them. The editors are connected whether or not they are shown;
+     * the selector is where that stops being invisible.
+     */
+    const previews = useEditorPreviews(workspace?.surfaceId ?? '');
+    const describe = (value, context) => {
+        const base = describeEditor(value, context);
+        const preview = previews[base.id];
+        return preview
+            ? { ...base, badge: preview.badge, details: preview.details }
+            : base;
+    };
+    return (_jsx(ViewSelector, { point: LoopEditorView, describe: describe, context: slotProps, 
+        // "Chat", not "None": with no editor beside it the conversation IS the
+        // view, and a control that names the common case after what it lacks
+        // reads as an error state.
+        noneLabel: "Chat", ariaLabel: "Editor" }));
+}
+export const ShellPlugin = definePlugin({
+    name: SHELL_PLUGIN_NAME,
+    // Named apart from the reactor's own `Shell` plugin, which sits beside it
+    // in the plugins panel: this is the Loop workspace's.
+    displayName: 'Loop shell',
+    description: 'The Loop workspace’s extension points, and the editor choice.',
+    octicon: 'columns',
+    emoji: '\u{1F4D1}',
+    config: {
+        defaultEditor: NONE_EDITOR,
+        showSelector: true,
+    },
+    /*
+     * The generic shell, configured for the loop. The selector is rendered by
+     * *this* plugin (below) rather than the generic one, because which slot it
+     * sits in and whether it shows are loop configuration; the generic
+     * keybinding is stood down so the loop's `/editor` keeps `Mod+Alt+E`
+     * without two commands fighting over one chord.
+     */
+    dependencies: [
+        configurePlugin(ReactorShellPlugin, {
+            point: LoopEditorView,
+            describe: describeEditor,
+            showSelector: false,
+            announce: (viewId) => requestSurface(viewId),
+            commandId: 'loop.shell.cycleEditor',
+            // Named for what it cycles here: the palette said "Switch the view" and
+            // a person looking for the notebook did not recognise it.
+            commandName: 'Switch the editor',
+            commandDescription: 'Cycle through the editors beside the conversation, and none',
+            keybinding: '',
+        }),
+    ],
+    // Declared, not merely used: the registry knows who contributed to a
+    // point, it cannot know who opened it — and these two are what makes this
+    // the plugin the others extend.
+    contributionPoints: [LoopViewType, LoopEditorView],
+    contributes: [
+        contribution(LoopCommand, {
+            name: 'editor',
+            aliases: ['editors'],
+            description: 'Switch the editor beside the conversation',
+            group: 'Open',
+            keybinding: 'Mod+Alt+E',
+            args: [
+                {
+                    name: 'editor',
+                    description: 'Which editor: none, or a surface id. Omit to cycle.',
+                    required: false,
+                    choices: () => [NONE_EDITOR, ...getEditorChoice().options],
+                },
+            ],
+            run: async ({ argv }) => {
+                const asked = argv.trim();
+                const wanted = asked === '' ? nextEditor() : asked;
+                const known = [NONE_EDITOR, ...getEditorChoice().options];
+                if (!known.includes(wanted)) {
+                    throw new Error(`No editor called '${wanted}'. There is: ${known.join(', ')}.`);
+                }
+                if (!chooseEditor(wanted)) {
+                    throw new Error('No chat is on screen to host the editor.');
+                }
+            },
+        }, { id: 'editor' }),
+    ],
+    build: ({ config }) => {
+        // The selector starts where the chat starts. Seeded, not requested: the
+        // chat's own `defaultSurface` is what actually opens the editor, and at
+        // build time there is no chat listening yet. The chat writes "no editor"
+        // as `''` or `'none'`; the selector's word for it is `'none'`.
+        seedEditorChoice(config.defaultEditor || NONE_EDITOR);
+        return {
+            components: config.showSelector
+                ? [
+                    {
+                        id: 'editor-selector',
+                        slot: LoopSlots.header,
+                        // The component holds itself to the trailing edge of the header
+                        // row with `marginLeft: 'auto'`, wherever the slot renders it.
+                        Component: EditorSelectorComponent,
+                    },
+                ]
+                : [],
+        };
+    },
+});
+export { NONE_EDITOR, chooseEditor, getEditorChoice, nextEditor, seedEditorChoice, setEditorOptions, subscribeEditorChoice, } from './editorChoice';
+/** The loop's selector, for a host that renders it somewhere of its own. */
+export { EditorSelectorComponent as EditorSelector };
+/** @deprecated The editors plugin grew into the shell plugin; same object. */
+export const EditorsPlugin = ShellPlugin;
+/** @deprecated See {@link SHELL_PLUGIN_NAME}. */
+export const EDITORS_PLUGIN_NAME = SHELL_PLUGIN_NAME;
+export default ShellPlugin;